fastworkflow 2.15.9__tar.gz → 2.15.10__tar.gz

{fastworkflow-2.15.9 → fastworkflow-2.15.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastworkflow
-Version: 2.15.9
+Version: 2.15.10
 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 → fastworkflow-2.15.10}/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-2.15.9 → fastworkflow-2.15.10}/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-2.15.9 → fastworkflow-2.15.10}/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-2.15.9 → fastworkflow-2.15.10}/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-2.15.9 → fastworkflow-2.15.10}/fastworkflow/utils/signatures.py

@@ -1,4 +1,5 @@
 import sys
+import ast
 import dspy
 import os
 from contextlib import suppress
@@ -318,7 +319,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 +336,234 @@ 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 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
+
+                        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)
+                                # 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
+
+                        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
+                            if t is str and isinstance(field_value, str):
+                                valid_by_type = True
+                                break
+                            # int
+                            if t is int:
+                                if isinstance(field_value, bool):
+                                    pass  # bool is subclass of int; treat as invalid here
+                                elif isinstance(field_value, int):
+                                    valid_by_type = True
+                                    break
+                                elif isinstance(field_value, str):
+                                    with suppress(Exception):
+                                        coerced = int(field_value.strip())
+                                        corrected_value = coerced
+                                        valid_by_type = True
+                                        break
+                            # float
+                            if t is float:
+                                if isinstance(field_value, (int, float)) and not isinstance(field_value, bool):
+                                    if isinstance(field_value, int):
+                                        corrected_value = float(field_value)
+                                    valid_by_type = True
+                                    break
+                                elif isinstance(field_value, str):
+                                    with suppress(Exception):
+                                        coerced = float(field_value.strip())
+                                        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_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
-
-            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")
+                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
 
-                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_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
 
-                else:
-                    pattern_regex = re.compile(pattern)
-                    if not pattern_regex.fullmatch(str(field_value)):
+                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", [])
@@ -390,6 +571,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 +610,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 +664,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-2.15.9 → fastworkflow-2.15.10}/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 → fastworkflow-2.15.10}/pyproject.toml

@@ -9,7 +9,7 @@ repository = "https://github.com/radiantlogicinc/fastworkflow"
 
 [tool.poetry]
 name = "fastworkflow"
-version = "2.15.9"
+version = "2.15.10"
 description = "A framework for rapidly building large-scale, deterministic, interactive workflows with a fault-tolerant, conversational UX"
 authors = ["Dhar Rawal <drawal@radiantlogic.com>"]
 license = "Apache-2.0"