fastworkflow 2.15.8__py3-none-any.whl → 2.15.10__py3-none-any.whl

fastworkflow/_workflows/command_metadata_extraction/intent_detection.py

@@ -0,0 +1,360 @@
+from typing import Optional
+import os
+from collections import Counter
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from pydantic import BaseModel
+from speedict import Rdict
+
+import fastworkflow
+from fastworkflow.utils.logging import logger
+from fastworkflow import NLUPipelineStage
+from fastworkflow.cache_matching import cache_match, store_utterance_cache
+from fastworkflow.model_pipeline_training import (
+    CommandRouter
+)
+
+from fastworkflow.utils.fuzzy_match import find_best_matches
+
+
+class CommandNamePrediction:
+    class Output(BaseModel):
+        command_name: Optional[str] = None
+        error_msg: Optional[str] = None
+        is_cme_command: bool = False
+
+    def __init__(self, cme_workflow: fastworkflow.Workflow):
+        self.cme_workflow = cme_workflow
+        self.app_workflow = cme_workflow.context["app_workflow"]
+        self.app_workflow_folderpath = self.app_workflow.folderpath
+        self.app_workflow_id = self.app_workflow.id
+
+        self.convo_path = os.path.join(self.app_workflow_folderpath, "___convo_info")
+        self.cache_path = self._get_cache_path(self.app_workflow_id, self.convo_path)
+        self.path = self._get_cache_path_cache(self.convo_path)
+
+    def predict(self, command_context_name: str, command: str, nlu_pipeline_stage: NLUPipelineStage) -> "CommandNamePrediction.Output":
+        # sourcery skip: extract-duplicate-method
+
+        model_artifact_path = f"{self.app_workflow_folderpath}/___command_info/{command_context_name}"
+        command_router = CommandRouter(model_artifact_path)
+
+        # Re-use the already-built ModelPipeline attached to the router
+        # instead of instantiating a fresh one.  This avoids reloading HF
+        # checkpoints and transferring tensors each time we see a new
+        # message for the same context.
+        modelpipeline = command_router.modelpipeline
+
+        crd = fastworkflow.RoutingRegistry.get_definition(
+            self.cme_workflow.folderpath)
+        cme_command_names = crd.get_command_names('IntentDetection')
+
+        valid_command_names = set()
+        if nlu_pipeline_stage == NLUPipelineStage.INTENT_AMBIGUITY_CLARIFICATION:
+            valid_command_names = self._get_suggested_commands(self.path)
+        elif nlu_pipeline_stage in (
+                NLUPipelineStage.INTENT_DETECTION, NLUPipelineStage.INTENT_MISUNDERSTANDING_CLARIFICATION):
+            app_crd = fastworkflow.RoutingRegistry.get_definition(
+                self.app_workflow_folderpath)
+            valid_command_names = (
+                set(cme_command_names) | 
+                set(app_crd.get_command_names(command_context_name))
+            )
+
+        command_name_dict = {
+            fully_qualified_command_name.split('/')[-1]: fully_qualified_command_name 
+            for fully_qualified_command_name in valid_command_names
+        }
+
+        if nlu_pipeline_stage == NLUPipelineStage.INTENT_AMBIGUITY_CLARIFICATION:
+            # what_can_i_do is special in INTENT_AMBIGUITY_CLARIFICATION
+            # We will not predict, just match plain utterances with exact or fuzzy match
+            command_name_dict |= {
+                plain_utterance: 'IntentDetection/what_can_i_do'
+                for plain_utterance in crd.command_directory.map_command_2_utterance_metadata[
+                    'IntentDetection/what_can_i_do'
+                ].plain_utterances
+            }
+
+        if nlu_pipeline_stage != NLUPipelineStage.INTENT_DETECTION:
+            # abort is special. 
+            # We will not predict, just match plain utterances with exact or fuzzy match
+            command_name_dict |= {
+                plain_utterance: 'ErrorCorrection/abort'
+                for plain_utterance in crd.command_directory.map_command_2_utterance_metadata[
+                    'ErrorCorrection/abort'
+                ].plain_utterances
+            }
+
+        if nlu_pipeline_stage != NLUPipelineStage.INTENT_MISUNDERSTANDING_CLARIFICATION:
+            # you_misunderstood is special. 
+            # We will not predict, just match plain utterances with exact or fuzzy match
+            command_name_dict |= {
+                plain_utterance: 'ErrorCorrection/you_misunderstood'
+                for plain_utterance in crd.command_directory.map_command_2_utterance_metadata[
+                    'ErrorCorrection/you_misunderstood'
+                ].plain_utterances
+            }
+
+        # See if the command starts with a command name followed by a space
+        tentative_command_name = command.split(" ", 1)[0]
+        normalized_command_name = tentative_command_name.lower()
+        command_name = None
+        if normalized_command_name in command_name_dict:
+            command_name = normalized_command_name
+            command = command.replace(f"{tentative_command_name}", "").strip().replace("  ", " ")
+        else:
+            # Use Levenshtein distance for fuzzy matching with the full command part after @
+            best_matched_commands, _ = find_best_matches(
+                command.replace(" ", "_"),
+                command_name_dict.keys(),
+                threshold=0.3  # Adjust threshold as needed
+            )
+            if best_matched_commands:
+                command_name = best_matched_commands[0]
+
+        if nlu_pipeline_stage == NLUPipelineStage.INTENT_DETECTION:
+            if not command_name:
+                if cache_result := cache_match(self.path, command, modelpipeline, 0.85):
+                    command_name = cache_result
+                else:
+                    predictions=command_router.predict(command)
+                    # predictions = majority_vote_predictions(command_router, command)
+
+                    if len(predictions)==1:
+                        command_name = predictions[0].split('/')[-1]
+                    else:
+                        # If confidence is low, treat as ambiguous command (type 1)
+                        error_msg = self._formulate_ambiguous_command_error_message(
+                            predictions, "run_as_agent" in self.app_workflow.context)
+
+                        # Store suggested commands
+                        self._store_suggested_commands(self.path, predictions, 1)
+                        return CommandNamePrediction.Output(error_msg=error_msg)
+
+        elif nlu_pipeline_stage in (
+            NLUPipelineStage.INTENT_AMBIGUITY_CLARIFICATION,
+            NLUPipelineStage.INTENT_MISUNDERSTANDING_CLARIFICATION
+        ) and not command_name:
+            command_name = "what_can_i_do"
+
+        if not command_name or command_name == "wildcard":
+            fully_qualified_command_name=None
+            is_cme_command=False
+        else:
+            fully_qualified_command_name = command_name_dict[command_name]
+            is_cme_command=(
+                fully_qualified_command_name in cme_command_names or 
+                fully_qualified_command_name in crd.get_command_names('ErrorCorrection')
+            )
+
+        if (
+            nlu_pipeline_stage
+            in (
+                NLUPipelineStage.INTENT_AMBIGUITY_CLARIFICATION,
+                NLUPipelineStage.INTENT_MISUNDERSTANDING_CLARIFICATION,
+            )
+            and not fully_qualified_command_name.endswith('abort')
+            and not fully_qualified_command_name.endswith('what_can_i_do')
+            and not fully_qualified_command_name.endswith('you_misunderstood')
+        ):
+            command = self.cme_workflow.context["command"]
+            store_utterance_cache(self.path, command, command_name, modelpipeline)
+
+        return CommandNamePrediction.Output(
+            command_name=fully_qualified_command_name,
+            is_cme_command=is_cme_command
+        )
+
+    @staticmethod
+    def _get_cache_path(workflow_id, convo_path):
+        """
+        Generate cache file path based on workflow ID
+        """
+        base_dir = convo_path
+        # Create directory if it doesn't exist
+        os.makedirs(base_dir, exist_ok=True)
+        return os.path.join(base_dir, f"{workflow_id}.db")
+
+    @staticmethod
+    def _get_cache_path_cache(convo_path):
+        """
+        Generate cache file path based on workflow ID
+        """
+        base_dir = convo_path
+        # Create directory if it doesn't exist
+        os.makedirs(base_dir, exist_ok=True)
+        return os.path.join(base_dir, "cache.db")
+
+    # Store the suggested commands with the flag type
+    @staticmethod
+    def _store_suggested_commands(cache_path, command_list, flag_type):
+        """
+        Store the list of suggested commands for the constrained selection
+
+        Args:
+            cache_path: Path to the cache database
+            command_list: List of suggested commands
+            flag_type: Type of constraint (1=ambiguous, 2=misclassified)
+        """
+        db = Rdict(cache_path)
+        try:
+            db["suggested_commands"] = command_list
+            db["flag_type"] = flag_type
+        finally:
+            db.close()
+
+    # Get the suggested commands
+    @staticmethod
+    def _get_suggested_commands(cache_path):
+        """
+        Get the list of suggested commands for the constrained selection
+        """
+        db = Rdict(cache_path)
+        try:
+            return db.get("suggested_commands", [])
+        finally:
+            db.close()
+
+    @staticmethod
+    def _get_count(cache_path):
+        db = Rdict(cache_path)
+        try:
+            return db.get("utterance_count", 0)  # Default to 0 if key doesn't exist
+        finally:
+            db.close()
+
+    @staticmethod
+    def _print_db_contents(cache_path):
+        db = Rdict(cache_path)
+        try:
+            print("All keys in database:", list(db.keys()))
+            for key in db.keys():
+                print(f"Key: {key}, Value: {db[key]}")
+        finally:
+            db.close()
+
+    @staticmethod
+    def _store_utterance(cache_path, utterance, label):
+        """
+        Store utterance in existing or new database
+        Returns: The utterance count used
+        """
+        # Open the database (creates if doesn't exist)
+        db = Rdict(cache_path)
+
+        try:
+            # Get existing counter or initialize to 0
+            utterance_count = db.get("utterance_count", 0)
+
+            # Create and store the utterance entry
+            utterance_data = {
+                "utterance": utterance,
+                "label": label
+            }
+
+            db[utterance_count] = utterance_data
+
+            # Increment and store the counter
+            utterance_count += 1
+            db["utterance_count"] = utterance_count
+
+            return utterance_count - 1  # Return the count used for this utterance
+
+        finally:
+            # Always close the database
+            db.close()
+
+    # Function to read from database
+    @staticmethod
+    def _read_utterance(cache_path, utterance_id):
+        """
+        Read a specific utterance from the database
+        """
+        db = Rdict(cache_path)
+        try:
+            return db.get(utterance_id)['utterance']
+        finally:
+            db.close()
+
+    @staticmethod
+    def _formulate_ambiguous_command_error_message(
+        route_choice_list: list[str], run_as_agent: bool) -> str:
+        command_list = (
+            "\n".join([
+                f"{route_choice.split('/')[-1].lower()}"
+                for route_choice in route_choice_list if route_choice != 'wildcard'
+            ])
+        )
+
+        return (
+            "The command is ambiguous. "
+            + (
+                "Choose the correct command name from these possible options and update your command:\n"
+                if run_as_agent
+                else "Please choose a command name from these possible options:\n"
+            )
+            + f"{command_list}\n\nor type 'what can i do' to see all commands\n"
+            + ("or type 'abort' to cancel" if run_as_agent else '')
+        )
+
+
+# TODO - generation is deterministic. They all return the same answer
+# TODO - Need 'temperature' for intent detection pipeline
+def majority_vote_predictions(command_router, command: str, n_predictions: int = 5) -> list[str]:
+    """
+    Generate N prediction sets in parallel and return the set that wins the majority vote.
+    
+    This function improves prediction reliability by running multiple parallel predictions
+    and selecting the most common result through majority voting. This helps reduce
+    the impact of random variations in model predictions.
+    
+    Args:
+        command_router: The CommandRouter instance to use for predictions
+        command: The input command string
+        n_predictions: Number of parallel predictions to generate (default: 5)
+                      Can be configured via N_PARALLEL_PREDICTIONS environment variable
+        
+    Returns:
+        The prediction set that received the majority vote. Falls back to a single
+        prediction if all parallel predictions fail.
+        
+    Note:
+        Uses ThreadPoolExecutor with max_workers limited to min(n_predictions, 10)
+        to avoid overwhelming the system with too many concurrent threads.
+    """
+    def get_single_prediction():
+        """Helper function to get a single prediction"""
+        return command_router.predict(command)
+    
+    # Generate N predictions in parallel
+    prediction_sets = []
+    with ThreadPoolExecutor(max_workers=min(n_predictions, 10)) as executor:
+        # Submit all prediction tasks
+        futures = [executor.submit(get_single_prediction) for _ in range(n_predictions)]
+        
+        # Collect results as they complete
+        for future in as_completed(futures):
+            try:
+                prediction_set = future.result()
+                prediction_sets.append(prediction_set)
+            except Exception as e:
+                logger.warning(f"Prediction failed: {e}")
+                # Continue with other predictions even if one fails
+    
+    if not prediction_sets:
+        # Fallback to single prediction if all parallel predictions failed
+        logger.warning("All parallel predictions failed, falling back to single prediction")
+        return command_router.predict(command)
+    
+    # Convert lists to tuples so they can be hashed and counted
+    prediction_tuples = [tuple(sorted(pred_set)) for pred_set in prediction_sets]
+    
+    # Count occurrences of each unique prediction set
+    vote_counts = Counter(prediction_tuples)
+    
+    # Get the prediction set with the most votes
+    winning_tuple = vote_counts.most_common(1)[0][0]
+    
+    # Convert back to list and return
+    return list(winning_tuple)

fastworkflow/_workflows/command_metadata_extraction/parameter_extraction.py

@@ -0,0 +1,327 @@
+import contextlib
+import sys
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel
+
+import fastworkflow
+from fastworkflow.utils.logging import logger
+from fastworkflow import ModuleType
+
+from fastworkflow.utils.signatures import InputForParamExtraction
+
+
+INVALID_INT_VALUE = -sys.maxsize
+INVALID_FLOAT_VALUE = -sys.float_info.max
+
+MISSING_INFORMATION_ERRMSG = fastworkflow.get_env_var("MISSING_INFORMATION_ERRMSG")
+INVALID_INFORMATION_ERRMSG = fastworkflow.get_env_var("INVALID_INFORMATION_ERRMSG")
+
+NOT_FOUND = fastworkflow.get_env_var("NOT_FOUND")
+INVALID = fastworkflow.get_env_var("INVALID")
+PARAMETER_EXTRACTION_ERROR_MSG = None
+
+
+class ParameterExtraction:
+    class Output(BaseModel):
+        parameters_are_valid: bool
+        cmd_parameters: Optional[BaseModel] = None
+        error_msg: Optional[str] = None
+        suggestions: Optional[Dict[str, List[str]]] = None
+
+    def __init__(self, cme_workflow: fastworkflow.Workflow, app_workflow: fastworkflow.Workflow, command_name: str, command: str):
+        self.cme_workflow = cme_workflow
+        self.app_workflow = app_workflow
+        self.command_name = command_name
+        self.command = command
+
+    def extract(self) -> "ParameterExtraction.Output":
+        app_workflow_folderpath = self.app_workflow.folderpath
+        app_command_routing_definition = fastworkflow.RoutingRegistry.get_definition(app_workflow_folderpath)
+
+        command_parameters_class = (
+            app_command_routing_definition.get_command_class(
+                self.command_name, ModuleType.COMMAND_PARAMETERS_CLASS
+            )
+        )
+        if not command_parameters_class:
+            return self.Output(parameters_are_valid=True)
+
+        stored_params = self._get_stored_parameters(self.cme_workflow)
+
+        self.command = self.command.replace(self.command_name, "").strip()
+
+        input_for_param_extraction = InputForParamExtraction.create(
+            self.app_workflow, self.command_name, 
+            self.command)
+
+        # If we have missing fields (in parameter extraction error state), try to apply the command directly
+        if stored_params:
+            new_params = self._extract_and_merge_missing_parameters(stored_params, self.command)
+        else:
+            # Otherwise use the LLM-based extraction
+            new_params = input_for_param_extraction.extract_parameters(
+                command_parameters_class, 
+                self.command_name, 
+                app_workflow_folderpath)
+
+        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}"
+
+            if "run_as_agent" not in self.app_workflow.context:
+                error_msg += "\nEnter 'abort' to get out of this error state and/or execute a different command."
+                error_msg += "\nEnter 'you misunderstood' if the wrong command was executed."
+            else:
+                error_msg += "\nCheck your command name if the wrong command was executed."
+            return self.Output(
+                parameters_are_valid=False,
+                error_msg=error_msg,
+                cmd_parameters=new_params,
+                suggestions=suggestions)
+
+        self._clear_parameters(self.cme_workflow)
+        return self.Output(
+            parameters_are_valid=True,
+            cmd_parameters=new_params)
+
+    @staticmethod
+    def _get_stored_parameters(cme_workflow: fastworkflow.Workflow):
+        return cme_workflow.context.get("stored_parameters")
+
+    @staticmethod
+    def _store_parameters(cme_workflow: fastworkflow.Workflow, parameters):
+        cme_workflow.context["stored_parameters"] = parameters
+
+    @staticmethod
+    def _clear_parameters(cme_workflow: fastworkflow.Workflow):
+        if "stored_parameters" in cme_workflow.context:
+            del cme_workflow.context["stored_parameters"]
+
+    @staticmethod
+    def _extract_missing_fields(input_for_param_extraction, sws, command_name, stored_params):
+        stored_missing_fields = []
+        is_valid, error_msg, _ = input_for_param_extraction.validate_parameters(
+            sws, command_name, stored_params
+        )
+
+        if not is_valid:
+            if MISSING_INFORMATION_ERRMSG in error_msg:
+                missing_fields_str = error_msg.split(f"{MISSING_INFORMATION_ERRMSG}")[1].split("\n")[0]
+                stored_missing_fields = [f.strip() for f in missing_fields_str.split(",")]
+            if INVALID_INFORMATION_ERRMSG in error_msg:
+                invalid_section = error_msg.split(f"{INVALID_INFORMATION_ERRMSG}")[1]
+                if "\n" in invalid_section:
+                    invalid_fields_str = invalid_section.split("\n")[0]
+                    stored_missing_fields.extend(
+                        invalid_field.split(" '")[0].strip()
+                        for invalid_field in invalid_fields_str.split(", ")
+                    )
+        return stored_missing_fields
+
+    @staticmethod
+    def _merge_parameters(old_params, new_params, missing_fields):
+        """
+        Merge new parameters with old parameters, prioritizing new values when appropriate.
+        """
+        merged_data = {
+            field_name: getattr(old_params, field_name, None)
+            for field_name in list(type(old_params).model_fields.keys())
+        }
+
+        # all_fields = list(old_params.model_fields.keys())
+        missing_fields = missing_fields or []
+
+        for field_name in missing_fields:
+            merged_data[field_name] = getattr(new_params, field_name)
+
+        # Construct the model instance without validation
+        return old_params.__class__.model_construct(**merged_data)
+
+            # if hasattr(new_params, field_name):
+            #     new_value = getattr(new_params, field_name)
+            #     old_value = merged_data.get(field_name)
+
+            #     if new_value is not None and new_value != NOT_FOUND:
+            #         if isinstance(old_value, str) and INVALID in old_value and INVALID not in new_value:
+            #             merged_data[field_name] = new_value
+
+            #         elif old_value is None or old_value == NOT_FOUND:
+            #             merged_data[field_name] = new_value
+
+            #         elif isinstance(old_value, int) and old_value == INVALID_INT_VALUE:
+            #             with contextlib.suppress(ValueError, TypeError):
+            #                 merged_data[field_name] = int(new_value)
+
+            #         elif isinstance(old_value, float) and old_value == INVALID_FLOAT_VALUE:
+            #             with contextlib.suppress(ValueError, TypeError):
+            #                 merged_data[field_name] = float(new_value)
+
+            #         elif (field_name in missing_fields and
+            #             hasattr(old_params.model_fields.get(field_name), "json_schema_extra") and
+            #             old_params.model_fields.get(field_name).json_schema_extra and
+            #             "db_lookup" in old_params.model_fields.get(field_name).json_schema_extra):
+            #             merged_data[field_name] = new_value
+
+            #         elif field_name in missing_fields:
+            #             field_info = old_params.model_fields.get(field_name)
+            #             has_pattern = hasattr(field_info, "pattern") and field_info.pattern is not None
+
+            #             if not has_pattern:
+            #                 for meta in getattr(field_info, "metadata", []):
+            #                     if hasattr(meta, "pattern"):
+            #                         has_pattern = True
+            #                         break
+
+            #             if not has_pattern and hasattr(field_info, "json_schema_extra") and field_info.json_schema_extra:
+            #                 has_pattern = "pattern" in field_info.json_schema_extra
+
+            #             if has_pattern:
+            #                 merged_data[field_name] = new_value
+
+    @staticmethod
+    def _format_parameters_for_display(params):
+        """
+        Format parameters for display in the error message.
+        """
+        if not params:
+            return ""
+
+        lines = []
+
+        all_fields = list(type(params).model_fields.keys())
+
+        for field_name in all_fields:
+            value = getattr(params, field_name, None)
+
+            if value in [
+                NOT_FOUND, 
+                None,
+                INVALID_INT_VALUE,
+                INVALID_FLOAT_VALUE
+            ]:
+                continue
+
+            display_name = " ".join(word.capitalize() for word in field_name.split('_'))
+
+            # Format fields appropriately based on type
+            if (
+                isinstance(value, bool)
+                or not hasattr(value, 'value')
+                and isinstance(value, (int, float))
+                or not hasattr(value, 'value')
+                and isinstance(value, str)
+                or not hasattr(value, 'value')
+            ):
+                lines.append(f"{display_name}: {value}")
+            else:  # Handle enum types
+                lines.append(f"{display_name}: {value.value}")
+        return "\n".join(lines)
+
+    @staticmethod
+    def _apply_missing_fields(command: str, default_params: BaseModel, missing_fields: list):
+        global PARAMETER_EXTRACTION_ERROR_MSG
+        if not PARAMETER_EXTRACTION_ERROR_MSG:
+            PARAMETER_EXTRACTION_ERROR_MSG = fastworkflow.get_env_var("PARAMETER_EXTRACTION_ERROR_MSG")
+
+        # Work on plain dict to avoid validation during assignment
+        params_data = {
+            field_name: getattr(default_params, field_name, None)
+            for field_name in list(type(default_params).model_fields.keys())
+        }
+
+        if "," in command:
+            parts = [part.strip() for part in command.split(",")]
+
+            if (
+                len(parts) == len(missing_fields) == 1
+                or len(parts) != len(missing_fields)
+                and parts
+                and missing_fields
+            ):
+                field = missing_fields[0]
+                if field in params_data:
+                    params_data[field] = parts[0]
+            elif len(parts) == len(missing_fields) and len(missing_fields) > 1:
+                for i, field in enumerate(missing_fields):
+                    if i < len(parts) and field in params_data:
+                        params_data[field] = parts[i]
+        elif missing_fields:
+            field = missing_fields[0]
+            if field in params_data:
+                params_data[field] = command.strip()
+
+        # Construct model without validation
+        return default_params.__class__.model_construct(**params_data)
+
+    @staticmethod
+    def _extract_and_merge_missing_parameters(stored_params: BaseModel, command: str):
+        """
+        Identify fields to fill by scanning for sentinel values and merge values
+        parsed from the command string into a new params instance. This preserves
+        existing behavior for token/field count mismatches and leaves values as
+        strings (no type coercion).
+        """
+        # Initialize with existing values to avoid triggering validation
+        field_names = list(type(stored_params).model_fields.keys())
+        params_data = {
+            field_name: getattr(stored_params, field_name, None)
+            for field_name in field_names
+        }
+
+        # Determine which fields still need user-provided input based on sentinels
+        fields_to_fill = []
+        for field_name in field_names:
+            value = getattr(stored_params, field_name, None)
+            if value in [
+                NOT_FOUND,
+                None,
+                INVALID_INT_VALUE,
+                INVALID_FLOAT_VALUE,
+            ]:
+                fields_to_fill.append(field_name)
+
+        if not fields_to_fill:
+            return stored_params
+
+        # Preserve existing mismatch handling and keep all values as strings
+        if "," in command:
+            parts = [part.strip() for part in command.split(",")]
+
+            if (
+                len(parts) == len(fields_to_fill) == 1
+                or len(parts) != len(fields_to_fill)
+                and parts
+            ):
+                field = fields_to_fill[0]
+                if field in params_data:
+                    params_data[field] = parts[0]
+            elif len(parts) == len(fields_to_fill) and len(fields_to_fill) > 1:
+                for i, field in enumerate(fields_to_fill):
+                    if i < len(parts) and field in params_data:
+                        params_data[field] = parts[i]
+        else:
+            field = fields_to_fill[0]
+            if field in params_data:
+                params_data[field] = command.strip()
+
+        # Return a new instance without validation
+        return stored_params.__class__.model_construct(**params_data)