fastworkflow 2.15.9__py3-none-any.whl → 2.15.11__py3-none-any.whl

fastworkflow/_workflows/command_metadata_extraction/_commands/wildcard.py

@@ -130,6 +130,13 @@ class ResponseGenerator:
             workflow_context["NLU_Pipeline_Stage"] = NLUPipelineStage.PARAMETER_EXTRACTION
             workflow.context = workflow_context
 
+        if nlu_pipeline_stage == NLUPipelineStage.PARAMETER_EXTRACTION:
+            cnp_output.command_name = workflow.context["command_name"]
+        else:
+            workflow_context = workflow.context
+            workflow_context["command_name"] = cnp_output.command_name
+            workflow.context = workflow_context
+
         command_name = cnp_output.command_name
         extractor = ParameterExtraction(workflow, app_workflow, command_name, command)
         pe_output = extractor.extract()

fastworkflow/_workflows/command_metadata_extraction/intent_detection.py

@@ -96,8 +96,8 @@ class CommandNamePrediction:
                 ].plain_utterances
             }
 
-        # See if the command starts with a command name followed by a space
-        tentative_command_name = command.split(" ", 1)[0]
+        # See if the command starts with a command name followed by a space or a '('
+        tentative_command_name = command.split(" ", 1)[0].split("(", 1)[0]
         normalized_command_name = tentative_command_name.lower()
         command_name = None
         if normalized_command_name in command_name_dict:

fastworkflow/_workflows/command_metadata_extraction/parameter_extraction.py

@@ -65,12 +65,24 @@ class ParameterExtraction:
                 self.command_name, 
                 app_workflow_folderpath)
 
-        self._store_parameters(self.cme_workflow, new_params)
-
-        is_valid, error_msg, suggestions = input_for_param_extraction.validate_parameters(
+        is_valid, error_msg, suggestions, missing_invalid_fields = \
+            input_for_param_extraction.validate_parameters(
             self.app_workflow, self.command_name, new_params
         )
 
+        # Set all the missing and invalid fields to None before storing
+        current_values = {
+            field_name: getattr(new_params, field_name, None)
+            for field_name in list(type(new_params).model_fields.keys())
+        }
+        for field_name in missing_invalid_fields:
+            if field_name in current_values:
+                current_values[field_name] = NOT_FOUND
+        # Reconstruct the model instance without validation
+        new_params = new_params.__class__.model_construct(**current_values)
+
+        self._store_parameters(self.cme_workflow, new_params)
+
         if not is_valid:
             if params_str := self._format_parameters_for_display(new_params):
                 error_msg = f"Extracted parameters so far:\n{params_str}\n\n{error_msg}"

fastworkflow/chat_session.py

@@ -345,9 +345,16 @@ class ChatSession:
             ) and self._status != SessionStatus.STOPPING:
                 try:
                     message = self.user_message_queue.get()
+
+                    if ((
+                            "NLU_Pipeline_Stage" not in self._cme_workflow.context or
+                            self._cme_workflow.context["NLU_Pipeline_Stage"] == fastworkflow.NLUPipelineStage.INTENT_DETECTION) and
+                        message.startswith('/')
+                    ):
+                        self._cme_workflow.context["is_assistant_mode_command"] = True
                     
                     # Route based on mode and message type
-                    if self._run_as_agent and not message.startswith('/'):
+                    if self._run_as_agent and "is_assistant_mode_command" not in self._cme_workflow.context:
                         # In agent mode, use workflow tool agent for processing
                         last_output = self._process_agent_message(message)
                     # elif self._is_mcp_tool_call(message):

fastworkflow/command_executor.py

@@ -45,7 +45,12 @@ class CommandExecutor(CommandExecutorInterface):
                 command = command)
         )
 
-        if command_output.command_handled or not command_output.success:           
+        if command_output.command_handled:       
+            # important to clear the current command mode from the workflow context
+            if "is_assistant_mode_command" in chat_session.cme_workflow._context:
+                del chat_session.cme_workflow._context["is_assistant_mode_command"]
+            return command_output
+        elif not command_output.success:       
             return command_output
 
         command_name = command_output.command_responses[0].artifacts["command_name"]
@@ -54,7 +59,7 @@ class CommandExecutor(CommandExecutorInterface):
         workflow = ChatSession.get_active_workflow()
         workflow_name = workflow.folderpath.split('/')[-1]
         context = workflow.current_command_context_displayname
-        
+
         command_routing_definition = fastworkflow.RoutingRegistry.get_definition(
             workflow.folderpath
         )
@@ -77,13 +82,17 @@ class CommandExecutor(CommandExecutorInterface):
             command_output = response_generation_object(workflow, command, input_obj)
         else:
             command_output = response_generation_object(workflow, command)
-            
+
         # Set the additional attributes
         command_output.workflow_name = workflow_name
         command_output.context = context
         command_output.command_name = command_name
         command_output.command_parameters = input_obj or None
 
+        # important to clear the current command mode from the workflow context
+        if "is_assistant_mode_command" in chat_session.cme_workflow._context:
+            del chat_session.cme_workflow._context["is_assistant_mode_command"]
+
         return command_output
 
     @classmethod
@@ -134,7 +143,7 @@ class CommandExecutor(CommandExecutorInterface):
             input_obj = command_parameters_class(**action.parameters)
 
             input_for_param_extraction = InputForParamExtraction(command=action.command)
-            is_valid, error_msg, _ = input_for_param_extraction.validate_parameters(
+            is_valid, error_msg, _, _ = input_for_param_extraction.validate_parameters(
                 workflow, action.command_name, input_obj
             )
             if not is_valid:

fastworkflow/examples/retail_workflow/_commands/find_user_id_by_email.py

@@ -11,16 +11,17 @@ from ..tools.find_user_id_by_email import FindUserIdByEmail
 
 
 class Signature:
-    """Find user id by email"""
+    """
+    Find user id by email. 
+    If email is not available, use `find_user_id_by_name_zip` instead.
+    As a last resort transfer to a human agent
+    """
     class Input(BaseModel):
         """Parameters taken from user utterance."""
 
         email: str = Field(
             default="NOT_FOUND",
-            description=(
-                "The email address to search for. If email is not available, "
-                "use `find_user_id_by_name_zip` instead. As a last resort transfer to a human agent"
-            ),
+            description="The email address to search for",
             pattern=r"^(NOT_FOUND|[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})$",
             examples=["user@example.com"],
         )

fastworkflow/utils/signatures.py

@@ -1,4 +1,5 @@
 import sys
+import ast
 import dspy
 import os
 from contextlib import suppress
@@ -156,7 +157,7 @@ Today's date is {today}.
     def create_signature_from_pydantic_model(
         pydantic_model: Type[BaseModel]
     ) -> Type[dspy.Signature]:
-            """
+        """
         Create a DSPy Signature class from a Pydantic model with type annotations.
         
         Args:
@@ -165,79 +166,76 @@ Today's date is {today}.
         Returns:
             A DSPy Signature class
         """
-            signature_components = {
-                "command": (str, dspy.InputField(desc="User's request"))
-            }
+        signature_components = {
+            "statement": (str, dspy.InputField(desc="Statement according to Dhar"))
+        }
 
-            steps = ["query: The original user query (Always include this)."]
-            field_num = 1
+        steps = []
+        field_num = 1
 
-            for attribute_name, attribute_metadata in pydantic_model.model_fields.items():
-                is_optional = False
-                attribute_type = attribute_metadata.annotation
+        for attribute_name, attribute_metadata in pydantic_model.model_fields.items():
+            is_optional = False
+            attribute_type = attribute_metadata.annotation
 
-                if hasattr(attribute_type, "__origin__") and attribute_type.__origin__ is Union:
-                    union_elements = get_args(attribute_type)
-                    if type(None) in union_elements:
-                        is_optional = True
-                        attribute_type = next((elem for elem in union_elements if elem is not type(None)), str)
-
-                NOT_FOUND = fastworkflow.get_env_var("NOT_FOUND")
-                if attribute_type is str:            
-                    default_value = NOT_FOUND
-                elif attribute_type is int:
-                    default_value = INVALID_INT_VALUE
-                elif attribute_type is float:
-                    default_value = -sys.float_info.max
-                else:
-                    default_value = None
+            if hasattr(attribute_type, "__origin__") and attribute_type.__origin__ is Union:
+                union_elements = get_args(attribute_type)
+                if type(None) in union_elements:
+                    is_optional = True
+                    attribute_type = next((elem for elem in union_elements if elem is not type(None)), str)
 
-                if (
-                    attribute_metadata.default is not PydanticUndefined and 
-                    attribute_metadata.default is not None and 
-                    attribute_metadata.default != Ellipsis
-                ):
-                    default_value = attribute_metadata.default
+            NOT_FOUND = fastworkflow.get_env_var("NOT_FOUND")
+            if attribute_type is str:            
+                default_value = NOT_FOUND
+            elif attribute_type is int:
+                default_value = INVALID_INT_VALUE
+            elif attribute_type is float:
+                default_value = -sys.float_info.max
+            else:
+                default_value = None
+
+            if (
+                attribute_metadata.default is not PydanticUndefined and 
+                attribute_metadata.default is not None and 
+                attribute_metadata.default != Ellipsis
+            ):
+                default_value = attribute_metadata.default
 
-                info_text = attribute_metadata.description or f"The {attribute_name}"
+            info_text = attribute_metadata.description or f"The {attribute_name}"
 
-                if attribute_name != "query": 
-                    steps.append(f"Step {field_num}: Identify the {attribute_name} ({info_text}).")
-                    field_num += 1
+            if attribute_name != "query": 
+                steps.append(f"Step {field_num}: Identify the {attribute_name} ({info_text}).")
+                field_num += 1
 
-                if isinstance(attribute_type, type) and issubclass(attribute_type, Enum):
-                    possible_values = [f"'{option.value}'" for option in attribute_type]
-                    info_text += f". Valid values: {', '.join(possible_values)}"
+            if isinstance(attribute_type, type) and issubclass(attribute_type, Enum):
+                possible_values = [f"'{option.value}'" for option in attribute_type]
+                info_text += f". Valid values: {', '.join(possible_values)}"
 
-                if attribute_metadata.examples:
-                    sample_values = ", ".join([f"'{sample}'" for sample in attribute_metadata.examples])
-                    info_text += f". Examples: {sample_values}"
+            if attribute_metadata.examples:
+                sample_values = ", ".join([f"'{sample}'" for sample in attribute_metadata.examples])
+                info_text += f". Examples: {sample_values}"
 
-                requirement_status = "Optional" if is_optional else "Required"
-                info_text += f". This field is {requirement_status}."
+            requirement_status = "Optional" if is_optional else "Required"
+            info_text += f". This field is {requirement_status}."
 
-                if is_optional:
-                    info_text += f" If not mentioned in the query, use: '{default_value or 'None'}'."
-                elif default_value is not None:
-                    info_text += f" Default value: '{default_value}'."
+            if is_optional:
+                info_text += f" If not mentioned in the query, use: '{default_value or 'None'}'."
+            elif default_value is not None:
+                info_text += f" Default value: '{default_value}'."
 
-                field_definition = dspy.OutputField(desc=info_text, default=default_value)
-                signature_components[attribute_name] = (attribute_metadata.annotation, field_definition)
+            field_definition = dspy.OutputField(desc=info_text, default=default_value)
+            signature_components[attribute_name] = (attribute_metadata.annotation, field_definition)
 
             steps.extend((
-                f"Step {field_num}: Check for any missing details.",
-                "Return the default value for the parameters for which default value is specified.",
-                "For parameters specified as enums, return the default value if the parameter value is not explicitly specified in the query",
-                "Return None for the parameter value which is missing in the query",
-                "Always return the query in the output.",
+                f"Step {field_num}: ",
+                "For missing parameter values - return the default if it is specified otherwise return None",
             ))
-            generated_docstring = f"""Extract structured parameters from a user query using step-by-step reasoning. Today's date is {date.today()}.
-
-        {chr(10).join(steps)}
-        """
-            instructions = generated_docstring
+            
+        generated_docstring = (
+            f"Extract parameter values from the statement according to Dhar. Today's date is {date.today()}.\n"
+            f"{chr(10).join(steps)}"
+        )
 
-            return dspy.Signature(signature_components, instructions)
+        return dspy.Signature(signature_components, generated_docstring)
     
     def extract_parameters(self, CommandParameters: Type[BaseModel] = None, subject_command_name: str = None, workflow_folderpath: str = None) -> BaseModel:
         """
@@ -269,7 +267,7 @@ Today's date is {today}.
                 self.predictor = dspy.ChainOfThought(signature)
                 
             def forward(self, command=None):
-                return self.predictor(command=command)
+                return self.predictor(statement=command)
         
         param_extractor = ParamExtractor(params_signature)
         
@@ -318,7 +316,7 @@ Today's date is {today}.
     def validate_parameters(self,
                             app_workflow: fastworkflow.Workflow, 
                             subject_command_name: str,
-                            cmd_parameters: BaseModel) -> Tuple[bool, str, Dict[str, List[str]]]:
+                            cmd_parameters: BaseModel) -> Tuple[bool, str, Dict[str, List[str]], List[str]]:
         """
         Check if the parameters are valid in the current context, including database lookups.
         """
@@ -335,54 +333,224 @@ Today's date is {today}.
         invalid_fields = []
         all_suggestions = {}
 
-        # Check required fields
         for field_name, field_info in type(cmd_parameters).model_fields.items():
-            field_value = getattr(cmd_parameters, field_name, None)
+                field_value = getattr(cmd_parameters, field_name, None)
+
+                if field_value not in [NOT_FOUND, None, INVALID_INT_VALUE, INVALID_FLOAT_VALUE]:
+                        annotation = field_info.annotation
+
+                        # Build list of candidate concrete types (exclude NoneType from Union)
+                        candidate_types: List[Type[Any]] = []
+                        if hasattr(annotation, "__origin__") and annotation.__origin__ is Union:
+                            for t in get_args(annotation):
+                                if t is not type(None):  # noqa: E721
+                                    candidate_types.append(t)  # type: ignore[arg-type]
+                        else:
+                            candidate_types = [annotation]  # type: ignore[list-item]
+
+                        def build_type_suggestion() -> List[str]:
+                            examples = getattr(field_info, "examples", []) or []
+                            example = examples[0] if examples else None
+                            # Enum suggestions list valid values
+                            enum_types = [t for t in candidate_types if isinstance(t, type) and issubclass(t, Enum)]
+                            if enum_types:
+                                opts = [f"'{opt.value}'" for t in enum_types for opt in t]
+                                return [f"Please provide a value matching the expected type/format. Valid values: {', '.join(opts)}"]
+                            # List suggestions
+                            def _is_list_type(tt):
+                                try:
+                                    return hasattr(tt, "__origin__") and tt.__origin__ in (list, List)
+                                except Exception:
+                                    return False
+                            list_types = [t for t in candidate_types if _is_list_type(t)]
+                            if list_types:
+                                inner_args = get_args(list_types[0])
+                                inner = inner_args[0] if inner_args else str
+                                inner_name = inner.__name__ if isinstance(inner, type) else str(inner)
+                                hint = (
+                                    f"Please provide a list of {inner_name} values. Accepted formats: "
+                                    f"JSON list (e.g., [\"a\", \"b\"]), Python list (e.g., ['a', 'b']), "
+                                    f"or comma-separated (e.g., a,b)."
+                                )
+                                return [hint]
+                            # Fallback: show expected type names (handles unions)
+                            name_list: List[str] = []
+                            for t in candidate_types:
+                                if isinstance(t, type):
+                                    name_list.append(t.__name__)
+                                else:
+                                    name_list.append(str(t))
+                            base = f"Please provide a value matching the expected type/format: {' or '.join(name_list)}"
+                            if example is not None:
+                                base = f"{base} (e.g., {example})"
+                            return [base]
+
+                        valid_by_type = False
+                        corrected_value: Optional[Any] = None
+                        def _is_list_type(tt):
+                            try:
+                                return hasattr(tt, "__origin__") and tt.__origin__ in (list, List)
+                            except Exception:
+                                return False
+
+                        def _parse_list_like_string(s: str) -> Optional[list]:
+                                if not isinstance(s, str):
+                                    return None
+                                text = s.strip()
+                                if text.startswith("[") and text.endswith("]"):
+                                        with suppress(Exception):
+                                                parsed = json.loads(text)
+                                                if isinstance(parsed, list):
+                                                    return parsed
+                                # Try Python literal list
+                                with suppress(Exception):
+                                        parsed = ast.literal_eval(text)
+                                        if isinstance(parsed, list):
+                                            return parsed
+                                # Fallback: comma-separated
+                                if "," in text:
+                                    parts = [p.strip() for p in text.split(",")]
+                                    cleaned = [
+                                        (p[1:-1] if len(p) >= 2 and ((p[0] == p[-1] == '"') or (p[0] == p[-1] == "'")) else p)
+                                        for p in parts
+                                    ]
+                                    return cleaned
+                                return None
+
+                        def _coerce_scalar(expected_type: Type[Any], val: Any) -> Tuple[bool, Optional[Any]]:
+                                # str
+                                if expected_type is str:
+                                    return True, str(val)
+                                # bool
+                                if expected_type is bool:
+                                    if isinstance(val, bool):
+                                        return True, val
+                                    elif isinstance(val, str):
+                                        lower_val = val.lower().strip()
+                                        if lower_val in ('true', 'false'):
+                                            return True, lower_val == 'true'
+                                        # Also handle string representations of integers
+                                        elif lower_val in ('0', '1'):
+                                            return True, lower_val == '1'
+                                    elif isinstance(val, int):
+                                        return True, bool(val)
+                                    return False, None
+                                # int
+                                if expected_type is int:
+                                    if isinstance(val, bool):
+                                        return False, None
+                                    if isinstance(val, int):
+                                        return True, val
+                                    if isinstance(val, str):
+                                        with suppress(Exception):
+                                            return True, int(val.strip())
+                                    return False, None
+                                # float
+                                if expected_type is float:
+                                    if isinstance(val, (int, float)) and not isinstance(val, bool):
+                                        return True, float(val)
+                                    if isinstance(val, str):
+                                        with suppress(Exception):
+                                            return True, float(val.strip())
+                                    return False, None
+                                # Enum
+                                if isinstance(expected_type, type) and issubclass(expected_type, Enum):
+                                    ok, enum_val = _try_coerce_enum(expected_type, val)
+                                    return (ok, enum_val if ok else None)
+                                                            # Unknown: accept if already instance
+                                return (True, val) if isinstance(val, expected_type) else (False, None)
+
+                        def _try_coerce_list(list_type: Any, value: Any) -> Tuple[bool, Optional[list]]:
+                            inner_args = get_args(list_type)
+                            inner_type = inner_args[0] if inner_args else str
+                            raw_list: Optional[list] = None
+                            if isinstance(value, list):
+                                raw_list = value
+                            elif isinstance(value, str):
+                                raw_list = _parse_list_like_string(value)
+                            if raw_list is None:
+                                return False, None
+                            coerced_list = []
+                            for item in raw_list:
+                                ok, coerced = _coerce_scalar(inner_type, item)
+                                if not ok:
+                                    return False, None
+                                coerced_list.append(coerced)
+                            return True, coerced_list
+
+                        def _try_coerce_enum(enum_cls: Type[Enum], val: Any) -> Tuple[bool, Optional[Enum]]:
+                            if isinstance(val, enum_cls):
+                                return True, val
+                            if isinstance(val, str):
+                                for member in enum_cls:
+                                    if val == member.value or val.lower() == str(member.name).lower():
+                                        return True, member
+                            return False, None
+
+                        for t in candidate_types:
+                            # list[...] and typing.List[...] support
+                            if _is_list_type(t):
+                                ok, coerced_list = _try_coerce_list(t, field_value)
+                                if ok:
+                                    corrected_value = coerced_list
+                                    valid_by_type = True
+                                    break
+                            # str, bool, int, float - use _coerce_scalar for consistency
+                            if t in (str, bool, int, float):
+                                ok, coerced = _coerce_scalar(t, field_value)
+                                if ok:
+                                    corrected_value = coerced
+                                    valid_by_type = True
+                                    break                            # Enum
+                            if isinstance(t, type) and issubclass(t, Enum):
+                                ok, enum_val = _try_coerce_enum(t, field_value)
+                                if ok:
+                                    corrected_value = enum_val
+                                    valid_by_type = True
+                                    break
+
+                        if valid_by_type:
+                            if corrected_value is not None:
+                                setattr(cmd_parameters, field_name, corrected_value)
+                        else:
+                            invalid_fields.append(f"{field_name} '{field_value}'")
+                            all_suggestions[field_name] = build_type_suggestion()
+                            is_valid = False
 
-            is_optional = False
-            attribute_type = field_info.annotation
-            if hasattr(attribute_type, "__origin__") and attribute_type.__origin__ is Union:
-                union_elements = get_args(attribute_type)
-                if type(None) in union_elements:
-                    is_optional = True
+                is_optional = False
+                attribute_type = field_info.annotation
+                if hasattr(attribute_type, "__origin__") and attribute_type.__origin__ is Union:
+                    union_elements = get_args(attribute_type)
+                    if type(None) in union_elements:
+                        is_optional = True
 
-            is_required=True
-            if is_optional:
-                    is_required=False
+                is_required=True
+                if is_optional:
+                        is_required=False
+
+                # Only add to missing fields if it's required AND has no value
+                if is_required and \
+                                field_value in [
+                        NOT_FOUND, 
+                        None,
+                        INVALID_INT_VALUE,
+                        INVALID_FLOAT_VALUE
+                    ]:
+                    missing_fields.append(field_name)
+                    is_valid = False
 
-            # Only add to missing fields if it's required AND has no value
-            if is_required and \
-                field_value in [
-                    NOT_FOUND, 
+                pattern = next(
+                    (meta.pattern
+                        for meta in getattr(field_info, "metadata", [])
+                        if hasattr(meta, "pattern")),
                     None,
-                    INVALID_INT_VALUE,
-                    INVALID_FLOAT_VALUE
-                ]:
-                missing_fields.append(field_name)
-                is_valid = False
-
-            pattern = next(
-                (meta.pattern
-                    for meta in getattr(field_info, "metadata", [])
-                    if hasattr(meta, "pattern")),
-                None,
-            )
-            if pattern and field_value is not None and field_value != NOT_FOUND:
-                invalid_value = None
-                if hasattr(field_info, "json_schema_extra") and field_info.json_schema_extra:
-                    invalid_value = field_info.json_schema_extra.get("invalid_value")
-
-                if invalid_value and field_value == invalid_value:
-                    invalid_fields.append(f"{field_name} '{field_value}'")
-                    pattern_str = str(pattern)
-                    examples = getattr(field_info, "examples", [])
-                    example = examples[0] if examples else ""
-                    all_suggestions[field_name] = [f"Please use the format matching pattern {pattern_str} (e.g., {example})"]
-                    is_valid = False
+                )
+                if pattern and field_value is not None and field_value != NOT_FOUND:
+                    invalid_value = None
+                    if hasattr(field_info, "json_schema_extra") and field_info.json_schema_extra:
+                        invalid_value = field_info.json_schema_extra.get("invalid_value")
 
-                else:
-                    pattern_regex = re.compile(pattern)
-                    if not pattern_regex.fullmatch(str(field_value)):
+                    if invalid_value and field_value == invalid_value:
                         invalid_fields.append(f"{field_name} '{field_value}'")
                         pattern_str = str(pattern)
                         examples = getattr(field_info, "examples", [])
@@ -390,6 +558,15 @@ Today's date is {today}.
                         all_suggestions[field_name] = [f"Please use the format matching pattern {pattern_str} (e.g., {example})"]
                         is_valid = False
 
+                    else:
+                        pattern_regex = re.compile(pattern)
+                        if not pattern_regex.fullmatch(str(field_value)):
+                            invalid_fields.append(f"{field_name} '{field_value}'")
+                            pattern_str = str(pattern)
+                            examples = getattr(field_info, "examples", [])
+                            example = examples[0] if examples else ""
+                            all_suggestions[field_name] = [f"Please use the format matching pattern {pattern_str} (e.g., {example})"]
+                            is_valid = False
 
         for field_name, field_info in type(cmd_parameters).model_fields.items():
             field_value = getattr(cmd_parameters, field_name, None)
@@ -420,20 +597,20 @@ Today's date is {today}.
         if is_valid:
             if not (
                 self.input_for_param_extraction_class and \
-                hasattr(self.input_for_param_extraction_class, 'validate_extracted_parameters')
+                            hasattr(self.input_for_param_extraction_class, 'validate_extracted_parameters')
             ):
-                return (True, "All required parameters are valid.", {})
-            
+                return (True, "All required parameters are valid.", {}, [])
+
             try:
                 is_valid, message = self.input_for_param_extraction_class.validate_extracted_parameters(app_workflow, subject_command_name, cmd_parameters)
             except Exception as e:
                 message = f"Exception in {subject_command_name}'s validate_extracted_parameters function: {str(e)}"
                 logger.critical(message)                    
-                return (False, message, {})
-            
+                return (False, message, {}, [])
+
             if is_valid:
-                return (True, "All required parameters are valid.", {})
-            return (False, message, {})
+                return (True, "All required parameters are valid.", {}, [])
+            return (False, message, {}, [])
 
         message = ''
         if missing_fields:
@@ -474,4 +651,4 @@ Today's date is {today}.
             if "run_as_agent" not in app_workflow.context:
                 message += "\nFor parameter values that include a comma, provide separately from other values, and one at a time."
 
-        return (False, message, all_suggestions)
+        return (False, message, all_suggestions, combined_fields)

fastworkflow/workflow.py

@@ -288,21 +288,17 @@ class Workflow:
     
     def end_command_processing(self) -> None:
         """Process the end of a command"""
-        mark_dirty = False
         # important to clear the current command from the workflow context
         if "command" in self._context:
             del self._context["command"]
-            mark_dirty = True
 
         # important to clear parameter extraction error state (if any)
         if "stored_parameters" in self._context:
             del self._context["stored_parameters"]
-            mark_dirty = True
 
         self._context["NLU_Pipeline_Stage"] = fastworkflow.NLUPipelineStage.INTENT_DETECTION
 
-        if mark_dirty:
-            self._mark_dirty()
+        self._mark_dirty()
 
     def close(self) -> bool:
         """close the session"""

{fastworkflow-2.15.9.dist-info → fastworkflow-2.15.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastworkflow
-Version: 2.15.9
+Version: 2.15.11
 Summary: A framework for rapidly building large-scale, deterministic, interactive workflows with a fault-tolerant, conversational UX
 License: Apache-2.0
 Keywords: fastworkflow,ai,workflow,llm,openai

{fastworkflow-2.15.9.dist-info → fastworkflow-2.15.11.dist-info}/RECORD

@@ -10,10 +10,10 @@ fastworkflow/_workflows/command_metadata_extraction/_commands/IntentDetection/re
 fastworkflow/_workflows/command_metadata_extraction/_commands/IntentDetection/what_can_i_do.py,sha256=Fw8tsk3wyCujf8nBfUgPDxnTP9c2IE513FzqAWGm8pU,6216
 fastworkflow/_workflows/command_metadata_extraction/_commands/IntentDetection/what_is_current_context.py,sha256=S5RQLr62Q2MnKU85nw4IW_ueAK_FXvhcY9gXajFxujg,1464
 fastworkflow/_workflows/command_metadata_extraction/_commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastworkflow/_workflows/command_metadata_extraction/_commands/wildcard.py,sha256=fUOiCMGfzoK3UBan2vMp6yj71OsQKkdyLyknE5jHSg8,6962
+fastworkflow/_workflows/command_metadata_extraction/_commands/wildcard.py,sha256=TphAB_rwR7giCx00hovGZ2p9Qh-q1VAOZQNJF0DjRJY,7287
 fastworkflow/_workflows/command_metadata_extraction/command_context_model.json,sha256=zGWBweQSmFf7WsfR_F2DE7AJ8S8-q7F9ZbvyccysJJI,117
-fastworkflow/_workflows/command_metadata_extraction/intent_detection.py,sha256=6A1q1OsivlW98nbMMfE1b9vjvFuLGRuKpv1Qvm0zHBk,14516
-fastworkflow/_workflows/command_metadata_extraction/parameter_extraction.py,sha256=6Sgt3foMFZg2RBPDbnPrxAdlZfnDyW8vPkGDr3PDadw,13117
+fastworkflow/_workflows/command_metadata_extraction/intent_detection.py,sha256=A0vzyHGMtBEWCzfTU_I9tnRx2Byu-ElJgfMugRlXkpA,14542
+fastworkflow/_workflows/command_metadata_extraction/parameter_extraction.py,sha256=MgNkPgA05E1-LSw9pNKDlXdsAphulYNhuDeTTqk5dBY,13686
 fastworkflow/build/__main__.py,sha256=NtedkZfM56qoEJ5vQECSURbE8AMTfwHN3tAZyZoWabk,15905
 fastworkflow/build/ast_class_extractor.py,sha256=F9OG4stkp7w3kadKqxMm8h3ZDSp_zg6mwcrKMl_XqdI,13527
 fastworkflow/build/class_analysis_structures.py,sha256=UWOKcs9pCiNuXc64hNywkTJq5X5KfG1pqdSZwWiZh-c,4053
@@ -35,11 +35,11 @@ fastworkflow/build/navigator_stub_generator.py,sha256=_DSvHC6r1xWQiFHtUgPhI51nQf
 fastworkflow/build/pydantic_model_generator.py,sha256=oNyoANyUWBpHG-fE3tGL911RNvDzQXjxAm0ssvuXUH4,1854
 fastworkflow/build/utterance_generator.py,sha256=UrtkF0wyAZ1hiFitHX0g8w7Wh-D0leLCrP1aUACSfHo,299
 fastworkflow/cache_matching.py,sha256=OoB--1tO6-O4BKCuCrUbB0CkUr76J62K4VAf6MShi-w,7984
-fastworkflow/chat_session.py,sha256=MVHSoygLIW4Gh3BRfDYSxmh5RMuBxc96c8E9QRW6ZyU,27563
+fastworkflow/chat_session.py,sha256=NHOMA_MdGh-lKm6gafEDiaRBrnrE7FbbR1g6oxredD4,28000
 fastworkflow/cli.py,sha256=li9OFT05sxqz4BZJc9byKAeTmomjLfsWMVuy0OiRGSs,18953
 fastworkflow/command_context_model.py,sha256=nWxLP3TR7WJr3yWCedqcdFOxo_kwae_mS3VRN2cOmK8,13437
 fastworkflow/command_directory.py,sha256=aJ6UQCwevfF11KbcQB2Qz6mQ7Kj91pZtvHmQY6JFnao,29030
-fastworkflow/command_executor.py,sha256=IEcuHEqrqc6I-Hpv451VIHw6z64zkO4o51MpXUFnPGo,7936
+fastworkflow/command_executor.py,sha256=UGM6JpOoZOYR3cbLOOLN3oziwNvUH-Cm-d1XFRzbW7k,8456
 fastworkflow/command_interfaces.py,sha256=PWIKlcp0G8nmYl0vkrg1o6QzJL0pxXkfrn1joqTa0eU,460
 fastworkflow/command_metadata_api.py,sha256=KtidE3PM9HYfY-nmEXZ8Y4nnaw2qn23p_gvwFVT3F8Y,39770
 fastworkflow/command_routing.py,sha256=R7194pcY0d2VHzmCu9ALacm1UvNuIRIvTn8mLp-EZIM,17219
@@ -87,7 +87,7 @@ fastworkflow/examples/messaging_app_4/startup_action.json,sha256=HhS0ApuK1wZmX2M
 fastworkflow/examples/retail_workflow/_commands/calculate.py,sha256=uj-Yg0RSiSPkK7Y0AZN1fgDdL0GWIw33g9ARAPGFFVU,2285
 fastworkflow/examples/retail_workflow/_commands/cancel_pending_order.py,sha256=npU7sERB915WJyqjuku6L63sxvXtrWGkjoTrU0nNhEU,4466
 fastworkflow/examples/retail_workflow/_commands/exchange_delivered_order_items.py,sha256=6g04D3eHUQdIBu3wqPbhHMjJUK_91uHxaZrlDggnFS0,5349
-fastworkflow/examples/retail_workflow/_commands/find_user_id_by_email.py,sha256=EhI1bNcmWETGllyb5Z91v0mRm8Ex4eQ44IQHZ244Syc,2793
+fastworkflow/examples/retail_workflow/_commands/find_user_id_by_email.py,sha256=EUGj_YJCIceebQghrlC3uDdJsxsAg2hxS3jFcaN3mX8,2761
 fastworkflow/examples/retail_workflow/_commands/find_user_id_by_name_zip.py,sha256=lA9UfEkBNjCXozM4fALSZZuS0DgO3W1qQ2cg0dv1XUA,3340
 fastworkflow/examples/retail_workflow/_commands/get_order_details.py,sha256=X5tcMfx0lBm5vot7Ssn8Uzg0UaTPJU7GTn0C8fGnGxM,3584
 fastworkflow/examples/retail_workflow/_commands/get_product_details.py,sha256=Qfzaz3hHNia9GJvR9Lhdv8qJWdy-GZ6VbzTCYyD4Hh8,2842
@@ -166,13 +166,13 @@ fastworkflow/utils/parameterize_func_decorator.py,sha256=V6YJnishWRCdwiBQW6P17hm
 fastworkflow/utils/pydantic_model_2_dspy_signature_class.py,sha256=w1pvl8rJq48ulFwaAtBgfXYn_SBIDBgq1aLMUg1zJn8,12875
 fastworkflow/utils/python_utils.py,sha256=OzSf-bGve1401SHM3QXXFauBOBrlGQzPNgvvGJPavX0,8200
 fastworkflow/utils/react.py,sha256=HubwmM4H9UzLaLaeIkJseKCNMjyrOXvMZz-8sw4ycCE,11224
-fastworkflow/utils/signatures.py,sha256=beDgLw54AN_IZra3d5ZhpDO7u1i5FJzVQeLhs6G_DRA,20951
+fastworkflow/utils/signatures.py,sha256=QOLX3j-AJkRWIkDhogbhxQo8MIt668xIKwd4SWiS2LY,31734
 fastworkflow/utils/startup_progress.py,sha256=9icSdnpFAxzIq0sUliGpNaH0Efvrt5lDtGfURV5BD98,3539
-fastworkflow/workflow.py,sha256=F7kGoNQbAMwy71zT1V_KF8PbRTCY4Dz-16Zv4ApK8m8,18939
+fastworkflow/workflow.py,sha256=37gn7e3ct-gdGw43zS6Ab_ADoJJBO4eJW2PywfUpjEg,18825
 fastworkflow/workflow_agent.py,sha256=iUcaE1fKLTiRNyDaochPpRHdijCiQBYaCWR8DdslO9Y,16028
 fastworkflow/workflow_inheritance_model.py,sha256=Pp-qSrQISgPfPjJVUfW84pc7HLmL2evuq0UVIYR51K0,7974
-fastworkflow-2.15.9.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-fastworkflow-2.15.9.dist-info/METADATA,sha256=o0zFSQTjmQVkWTTRwjRTKE94k_-6MDLE5kSUHW5GwQY,30065
-fastworkflow-2.15.9.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-fastworkflow-2.15.9.dist-info/entry_points.txt,sha256=m8HqoPzCyaZLAx-V5X8MJgw3Lx3GiPDlxNEZ7K-Gb-U,54
-fastworkflow-2.15.9.dist-info/RECORD,,
+fastworkflow-2.15.11.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fastworkflow-2.15.11.dist-info/METADATA,sha256=Wye3szQ8uZSJktp5hs4odNvQTP7k88YPiAzjXfWc_80,30066
+fastworkflow-2.15.11.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+fastworkflow-2.15.11.dist-info/entry_points.txt,sha256=m8HqoPzCyaZLAx-V5X8MJgw3Lx3GiPDlxNEZ7K-Gb-U,54
+fastworkflow-2.15.11.dist-info/RECORD,,