fastworkflow 2.17.7__tar.gz → 2.17.9__tar.gz

{fastworkflow-2.17.7 → fastworkflow-2.17.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastworkflow
-Version: 2.17.7
+Version: 2.17.9
 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.17.7 → fastworkflow-2.17.9}/fastworkflow/_workflows/command_metadata_extraction/parameter_extraction.py

@@ -1,8 +1,10 @@
 import contextlib
 import sys
+import re
 from typing import Dict, List, Optional
 
 from pydantic import BaseModel
+from pydantic_core import PydanticUndefined
 
 import fastworkflow
 from fastworkflow.utils.logging import logger
@@ -59,11 +61,29 @@ class ParameterExtraction:
         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)
+            # Check if we're in agentic mode (not assistant mode command)
+            is_agentic_mode = (
+                "is_assistant_mode_command" not in self.cme_workflow.context
+                and "run_as_agent" in self.app_workflow.context
+                and self.app_workflow.context["run_as_agent"]
+            )
+
+            if is_agentic_mode:
+                # Try regex-based extraction first in agentic mode
+                new_params = self._extract_parameters_from_xml(self.command, command_parameters_class)
+
+                # If regex extraction fails, fall back to LLM-based extraction
+                if new_params is None:
+                    new_params = input_for_param_extraction.extract_parameters(
+                        command_parameters_class,
+                        self.command_name,
+                        app_workflow_folderpath)
+            else:
+                # Use LLM-based extraction for assistant mode
+                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(
@@ -272,6 +292,62 @@ class ParameterExtraction:
         # Construct model without validation
         return default_params.__class__.model_construct(**params_data)
 
+    @staticmethod
+    def _extract_parameters_from_xml(command: str, command_parameters_class: type[BaseModel]) -> Optional[BaseModel]:
+        """
+        Extract parameters from XML-formatted command using regex.
+
+        Returns:
+            BaseModel instance with extracted parameters, or None if parsing fails
+        """
+        field_names = list(command_parameters_class.model_fields.keys())
+
+        # If no parameters are defined, return empty model immediately
+        if not field_names:
+            return command_parameters_class.model_construct()
+
+        extracted_data = {}
+
+        # Try to extract each parameter using XML tags
+        for field_name in field_names:
+            # Look for <field_name>value</field_name> pattern
+            pattern = rf'<{re.escape(field_name)}>(.+?)</{re.escape(field_name)}>'
+            if match := re.search(pattern, command, re.DOTALL):
+                parameter_value = match[1].strip()
+                extracted_data[field_name] = parameter_value
+
+        # Check if we extracted values for ALL fields (safest criteria for LLM fallback)
+        all_fields_extracted = len(extracted_data) == len(field_names)
+
+        # Check if agent used example values
+        if all_fields_extracted:
+            for field_name, extracted_value in extracted_data.items():
+                field_info = command_parameters_class.model_fields[field_name]
+                examples = getattr(field_info, "examples", None)
+                if examples and extracted_value in examples:
+                    all_fields_extracted = False
+                    break
+
+        if all_fields_extracted:
+            # Initialize all fields with their default values (if they exist) or None
+            params_data = {}
+            for field_name in field_names:
+                field_info = command_parameters_class.model_fields[field_name]
+                if field_info.default is not PydanticUndefined:
+                    params_data[field_name] = field_info.default
+                elif field_info.default_factory is not None:
+                    params_data[field_name] = field_info.default_factory()
+                else:
+                    params_data[field_name] = None
+
+            # Update with extracted values
+            params_data |= extracted_data
+
+            # Construct model without validation
+            return command_parameters_class.model_construct(**params_data)
+
+        return None
+
     @staticmethod
     def _extract_and_merge_missing_parameters(stored_params: BaseModel, command: str):
         """

{fastworkflow-2.17.7 → fastworkflow-2.17.9}/fastworkflow/chat_session.py

@@ -133,7 +133,8 @@ class ChatSession:
         
         # Initialize agent-related attributes
         self._run_as_agent = run_as_agent
-        self._workflow_tool_agent = None            
+        self._workflow_tool_agent = None
+        self._intent_clarification_agent = None            
         
         # Create the command metadata extraction workflow with a unique ID
         self._cme_workflow = fastworkflow.Workflow.create(
@@ -272,13 +273,23 @@ class ChatSession:
         self._current_workflow.context["run_as_agent"] = True
 
         # Initialize the workflow tool agent
-        from fastworkflow.workflow_agent import initialize_workflow_tool_agent       
+        from fastworkflow.workflow_agent import initialize_workflow_tool_agent
         self._workflow_tool_agent = initialize_workflow_tool_agent(self)
 
+        # Initialize the intent clarification agent
+        from fastworkflow.intent_clarification_agent import initialize_intent_clarification_agent
+        self._intent_clarification_agent = initialize_intent_clarification_agent(self)
+
     @property
     def workflow_tool_agent(self):
         """Get the workflow tool agent for agent mode."""
         return self._workflow_tool_agent
+
+    @property
+    def intent_clarification_agent(self):
+        """Get the intent clarification agent for agent mode."""
+        return self._intent_clarification_agent
+
     @property
     def cme_workflow(self) -> fastworkflow.Workflow:
         """Get the command metadata extraction workflow."""
@@ -647,7 +658,7 @@ class ChatSession:
     def _extract_conversation_summary(self, 
         user_query: str, workflow_actions: list[dict[str, str]], final_agent_response: str) -> str:
         """
-        Summarizes conversation based on original user query, workflow actions and agentt response.
+        Summarizes conversation based on original user query, workflow actions and agent response.
         Returns the conversation summary and the log entry
         """
         # Lets log everything to a file called action_log.jsonl, if it exists

{fastworkflow-2.17.7 → fastworkflow-2.17.9}/fastworkflow/command_metadata_api.py

@@ -613,6 +613,56 @@ class CommandMetadataAPI:
 
         return "\n".join(combined_lines)
 
+    @staticmethod
+    def get_suggested_commands_metadata(
+        subject_workflow_path: str,
+        cme_workflow_path: str,
+        active_context_name: str,
+        suggested_command_names: list[str],
+        for_agents: bool = False,
+    ) -> str:
+        """
+        Get metadata display text for ONLY the suggested commands.
+
+        Args:
+            subject_workflow_path: Path to the subject workflow
+            cme_workflow_path: Path to the CME workflow
+            active_context_name: Active context name
+            suggested_command_names: List of suggested command names (can be short names or qualified)
+            for_agents: Include agent-specific fields
+
+        Returns:
+            YAML-like formatted string with metadata for suggested commands only
+        """
+        if not suggested_command_names:
+            return "No suggested commands provided."
+
+        parts: list[str] = []
+        for suggested_cmd in suggested_command_names:
+            # Try to get metadata for this command
+            # The command name could be qualified (Context/command) or short (command)
+            if part := CommandMetadataAPI.get_command_display_text_for_command(
+                subject_workflow_path=subject_workflow_path,
+                cme_workflow_path=cme_workflow_path,
+                active_context_name=active_context_name,
+                qualified_command_name=suggested_cmd,
+                for_agents=for_agents,
+            ):
+                parts.append(part)
+
+        if not parts:
+            return "No metadata available for suggested commands."
+
+        # Combine all parts with header
+        combined_lines: list[str] = ["Suggested commands with metadata:"]
+        for idx, text in enumerate(parts):
+            lines = text.splitlines()
+            if idx > 0:
+                combined_lines.append("")  # Blank line separator
+            combined_lines.extend(lines)
+
+        return "\n".join(combined_lines)
+
     @staticmethod
     def get_command_display_text_for_command(
         subject_workflow_path: str,

fastworkflow-2.17.9/fastworkflow/intent_clarification_agent.py

@@ -0,0 +1,132 @@
+"""
+Intent detection error state agent module for fastWorkflow.
+Specialized agent for handling intent detection errors.
+"""
+
+import json
+import dspy
+
+import fastworkflow
+from fastworkflow.utils.react import fastWorkflowReAct
+from fastworkflow.command_metadata_api import CommandMetadataAPI
+
+
+class IntentClarificationAgentSignature(dspy.Signature):
+    """
+    Handle intent detection errors by clarifying user intent.
+    You are provided with:
+    1. The workflow agent's inputs and trajectory - showing what the agent has been trying to do
+    2. Suggested commands metadata (for intent ambiguity) or empty (for intent misunderstanding - use show_available_commands tool)
+
+    Review the agent trajectory to understand the context and what led to this error.
+    If suggested_commands_metadata is provided, review it carefully to understand each command's purpose, parameters, and usage.
+    If suggested_commands_metadata is empty, use the show_available_commands tool to get the full list of available commands.
+    IMPORTANT: When clarifying intent, preserve ALL parameters from the original command.
+    Use available tools to resolve ambiguous or misunderstood commands. Use the ask_user tool ONLY as a last resort. Return the complete clarified command with the correct name and all original parameters.
+    """
+    original_command = dspy.InputField(desc="The original command with all parameters that caused the error.")
+    error_message = dspy.InputField(desc="The intent detection error message from the workflow.")
+    agent_inputs = dspy.InputField(desc="The original inputs to the workflow agent.")
+    agent_trajectory = dspy.InputField(desc="The workflow agent's trajectory showing all actions taken so far leading to this error.")
+    suggested_commands_metadata = dspy.InputField(desc="Metadata for suggested commands (for ambiguity clarification), or empty string (for misunderstanding - use show_available_commands tool instead).")
+    clarified_command = dspy.OutputField(desc="The complete command with correct command name AND all original parameters preserved.")
+
+
+def _show_available_commands(chat_session: fastworkflow.ChatSession) -> str:
+    """
+    Show available commands to help resolve intent detection errors.
+
+    Args:
+        chat_session: The chat session instance
+
+    Returns:
+        List of available commands
+    """
+
+    current_workflow = chat_session.get_active_workflow()
+    return CommandMetadataAPI.get_command_display_text(
+        subject_workflow_path=current_workflow.folderpath,
+        cme_workflow_path=fastworkflow.get_internal_workflow_path("command_metadata_extraction"),
+        active_context_name=current_workflow.current_command_context_name,
+    )
+
+
+def _ask_user_for_clarification(
+    clarification_request: str,
+    chat_session: fastworkflow.ChatSession
+) -> str:
+    """
+    Ask user for clarification when intent is unclear.
+
+    Args:
+        clarification_request: The question to ask the user
+        chat_session: The chat session instance
+
+    Returns:
+        User's response
+    """
+    command_output = fastworkflow.CommandOutput(
+        command_responses=[fastworkflow.CommandResponse(response=clarification_request)],
+        workflow_name=chat_session.get_active_workflow().folderpath.split('/')[-1]
+    )
+    chat_session.command_output_queue.put(command_output)
+
+    user_response = chat_session.user_message_queue.get()
+
+    # Log to action.jsonl (shared with main agent)
+    with open("action.jsonl", "a", encoding="utf-8") as f:
+        agent_user_dialog = {
+            "intent_clarification_agent": True,
+            "agent_query": clarification_request,
+            "user_response": user_response
+        }
+        f.write(json.dumps(agent_user_dialog, ensure_ascii=False) + "\n")
+
+    return user_response
+
+
+def initialize_intent_clarification_agent(
+    chat_session: fastworkflow.ChatSession,
+    max_iters: int = 20
+):
+    """
+    Initialize a specialized agent for handling intent detection errors.
+    This agent has a limited tool set and shares traces with the main execution agent.
+
+    Args:
+        chat_session: The chat session instance
+        max_iters: Maximum iterations for the agent (default: 10)
+
+    Returns:
+        DSPy ReAct agent configured for intent detection error handling
+    """
+    if not chat_session:
+        raise ValueError("chat_session cannot be null")
+
+    def show_available_commands() -> str:
+        """
+        Show all available commands to help resolve intent ambiguity.
+        """
+        return _show_available_commands(chat_session)
+
+    def ask_user(clarification_request: str) -> str:
+        """
+        Ask the user for clarification when the intent is unclear.
+        Use this as a last resort when you cannot determine the correct command.
+
+        Args:
+            clarification_request: Clear question to ask the user
+        """
+        return _ask_user_for_clarification(clarification_request, chat_session)
+
+    # Limited tool set for intent detection errors
+    tools = [
+        show_available_commands,
+        ask_user,
+    ]
+
+    return fastWorkflowReAct(
+        IntentClarificationAgentSignature,
+        tools=tools,
+        max_iters=max_iters,
+    )

{fastworkflow-2.17.7 → fastworkflow-2.17.9}/fastworkflow/run_fastapi_mcp/README.md

@@ -82,6 +82,32 @@ uvicorn services.run_fastapi.main:app --workflow_path /path/to/workflow --expect
 - Tokens without valid signatures are rejected
 - Recommended for production deployments in untrusted environments
 
+### Token Access in Workflow Context
+
+JWT tokens are automatically passed to workflows via the `workflow_context` parameter as `http_bearer_token`. This allows workflows to access the bearer token for making authenticated API calls or forwarding authentication.
+
+**Important notes:**
+- The token is **only available to authenticated endpoints** (those using `get_session_and_ensure_runtime` dependency)
+- The token is stored in the workflow context dictionary under the key `http_bearer_token`
+- Token is **automatically updated** on every authenticated request, ensuring workflows always have the current valid token
+- Token expiration is **automatically verified** by `verify_token()` in both secure mode (`--expect_encrypted_jwt` flag) and trusted network mode
+- In secure mode: Full cryptographic signature verification + expiration checking
+- In trusted network mode: Expiration checking is performed (signature verification disabled)
+- Tokens should be treated as sensitive data and handled securely in workflows
+- The `/initialize` endpoint is unauthenticated and does NOT provide a token to the workflow context; tokens are only available after calling `/initialize` and using the returned token in subsequent requests
+
+**Example usage in workflow:**
+
+```python
+# In workflow code
+workflow_context = self._context  # Gets the workflow_context
+bearer_token = workflow_context.get('http_bearer_token')
+
+# Use token for API calls
+headers = {"Authorization": f"Bearer {bearer_token}"}
+response = requests.get("https://api.example.com/data", headers=headers)
+```
+
 ## API Endpoints (REST)
 
 ### `POST /initialize`

{fastworkflow-2.17.7 → fastworkflow-2.17.9}/fastworkflow/run_fastapi_mcp/__main__.py

@@ -126,7 +126,8 @@ async def get_session_and_ensure_runtime(
         workflow_path=ARGS.workflow_path,
         context=json.loads(ARGS.context) if ARGS.context else None,
         startup_command=ARGS.startup_command,
-        startup_action=fastworkflow.Action(**json.loads(ARGS.startup_action)) if ARGS.startup_action else None
+        startup_action=fastworkflow.Action(**json.loads(ARGS.startup_action)) if ARGS.startup_action else None,
+        http_bearer_token=session.http_bearer_token
     )
     
     return session

{fastworkflow-2.17.7 → fastworkflow-2.17.9}/fastworkflow/run_fastapi_mcp/jwt_manager.py

@@ -269,6 +269,14 @@ def verify_token(token: str, expected_type: str = "access") -> dict:
             logger.warning(f"Token decoding failed: {e}")
             raise JWTError(f"Failed to decode token: {e}") from e
         
+        # Manually check expiration even in unverified mode
+        if exp_timestamp := payload.get("exp"):
+            import time
+            current_time = int(time.time())
+            if exp_timestamp < current_time:
+                logger.warning(f"Token expired: exp={exp_timestamp}, now={current_time}")
+                raise JWTError("Token has expired")
+        
         # Validate token type for consistency (outside try-except to allow JWTError to propagate)
         if payload.get("type") != expected_type:
             raise JWTError(f"Invalid token type: expected {expected_type}, got {payload.get('type')}")

{fastworkflow-2.17.7 → fastworkflow-2.17.9}/fastworkflow/run_fastapi_mcp/utils.py

@@ -42,6 +42,7 @@ class SessionData(BaseModel):
     issued_at: int  # Unix timestamp
     expires_at: int  # Unix timestamp
     jti: str  # JWT ID (unique token identifier)
+    http_bearer_token: Optional[str] = None  # The actual JWT token string for workflow context access
 
 
 class InvokeRequest(BaseModel):
@@ -174,13 +175,14 @@ def get_session_from_jwt(
     try:
         payload = verify_token(token, expected_type="access")
 
-        # Extract session data from payload
+        # Extract session data from payload, including the token for workflow context
         return SessionData(
             user_id=payload["sub"],
             token_type=payload["type"],
             issued_at=payload["iat"],
             expires_at=payload["exp"],
-            jti=payload["jti"]
+            jti=payload["jti"],
+            http_bearer_token=token  # Store the actual token for workflow access
         )
 
     except JWTError as e:
@@ -204,7 +206,8 @@ async def ensure_user_runtime_exists(
     context: Optional[dict] = None,
     startup_command: Optional[str] = None,
     startup_action: Optional['fastworkflow.Action'] = None,
-    stream_format: str = "ndjson"
+    stream_format: str = "ndjson",
+    http_bearer_token: Optional[str] = None
 ) -> None:
     """
     Ensure a user runtime exists in the session manager. If not, create it.
@@ -220,6 +223,7 @@ async def ensure_user_runtime_exists(
         startup_command: Optional startup command
         startup_action: Optional startup action
         stream_format: Stream format preference ("ndjson" or "sse", default "ndjson")
+        http_bearer_token: Optional JWT token to update in workflow context
         
     Raises:
         HTTPException: If session creation fails
@@ -228,8 +232,30 @@ async def ensure_user_runtime_exists(
     existing_runtime = await session_manager.get_session(user_id)
     if existing_runtime:
         logger.debug(f"Session for user_id {user_id} already exists, skipping creation")
+        
+        # Update the workflow's context with the current token if provided
+        if http_bearer_token and existing_runtime.chat_session:
+            active_workflow = existing_runtime.chat_session.get_active_workflow()
+            if active_workflow and active_workflow.context:
+                # Update the workflow's context with the current token
+                # Note: We mutate the dictionary in-place (no setter call), which means:
+                # 1. The change is immediate and visible to workflow code
+                # 2. The workflow is NOT marked dirty (won't persist to disk)
+                # 3. This is intentional for JWT tokens - we don't want to persist sensitive tokens
+                active_workflow.context['http_bearer_token'] = http_bearer_token
+                logger.debug(f"Updated http_bearer_token in workflow context for user_id {user_id}")
+        
         return
     
+    # Prepare workflow context, ensuring http_bearer_token is available
+    if http_bearer_token:
+        if context:
+            # Add or replace http_bearer_token in the context
+            context['http_bearer_token'] = http_bearer_token
+        else:
+            # Initialize context with http_bearer_token
+            context = {'http_bearer_token': http_bearer_token}
+    
     logger.info(f"Creating new session for user_id: {user_id}")
     
     # Resolve conversation store base folder from SPEEDDICT_FOLDERNAME/user_conversations

{fastworkflow-2.17.7 → fastworkflow-2.17.9}/fastworkflow/train/__main__.py

@@ -114,7 +114,7 @@ def _get_commands_with_parameters(json_path):
         command_directory = json.load(f)
     
     # Extract the command metadata
-    commands_metadata = command_directory.get("map_commandkey_2_metadata", {})
+    commands_metadata = command_directory.get("map_command_2_metadata", {})
     
     # Initialize result dictionary
     commands_with_parameters = {}

{fastworkflow-2.17.7 → fastworkflow-2.17.9}/fastworkflow/utils/react.py

@@ -2,6 +2,7 @@ import logging
 from typing import TYPE_CHECKING, Any, Callable, Literal
 
 from litellm import ContextWindowExceededError
+from litellm import exceptions as litellm_exceptions
 
 import dspy
 from dspy.adapters.types.tool import Tool
@@ -41,6 +42,7 @@ class fastWorkflowReAct(Module):
         super().__init__()
         self.signature = signature = ensure_signature(signature)
         self.max_iters = max_iters
+        self.iteration_counter = 0
 
         tools = [t if isinstance(t, Tool) else Tool(t) for t in tools]
         tools = {tool.name: tool for tool in tools}
@@ -105,7 +107,8 @@ class fastWorkflowReAct(Module):
 
         trajectory = {}
         max_iters = input_args.pop("max_iters", self.max_iters)
-        for idx in range(max_iters):
+        idx = 0
+        while True:
             try:
                 pred = self._call_with_potential_trajectory_truncation(self.react, trajectory, **input_args)
             except ValueError as err:
@@ -126,6 +129,12 @@ class fastWorkflowReAct(Module):
             if pred.next_tool_name == "finish":
                 break
 
+            idx += 1 # this is the counter for the index of the entire trajectory
+            self.iteration_counter += 1 # this counter just determines the number of times we run the react agent and it's reset everytime we call the user for clarification
+            if self.iteration_counter >= max_iters:
+                logger.warning("Max iterations reached")
+                break
+
         extract = self._call_with_potential_trajectory_truncation(self.extract, trajectory, **input_args)
         return dspy.Prediction(trajectory=trajectory, **extract)
 
@@ -161,6 +170,9 @@ class fastWorkflowReAct(Module):
                     **input_args,
                     trajectory=self._format_trajectory(trajectory),
                 )
+            except litellm_exceptions.BadRequestError: 
+                logger.warning("Trajectory exceeded the context window, truncating the oldest tool call information.")
+                trajectory = self.truncate_trajectory(trajectory)
             except ContextWindowExceededError:
                 logger.warning("Trajectory exceeded the context window, truncating the oldest tool call information.")
                 trajectory = self.truncate_trajectory(trajectory)

{fastworkflow-2.17.7 → fastworkflow-2.17.9}/fastworkflow/utils/signatures.py

@@ -407,7 +407,7 @@ Today's date is {today}.
                                         parsed = ast.literal_eval(text)
                                         if isinstance(parsed, list):
                                             return parsed
-                                # Fallback: comma-separated
+                                # Comma-separated values
                                 if "," in text:
                                     parts = [p.strip() for p in text.split(",")]
                                     cleaned = [
@@ -415,6 +415,12 @@ Today's date is {today}.
                                         for p in parts
                                     ]
                                     return cleaned
+                                # Single value - treat as a list with one element
+                                if text:
+                                    # Remove quotes if present
+                                    if len(text) >= 2 and ((text[0] == text[-1] == '"') or (text[0] == text[-1] == "'")):
+                                        return [text[1:-1]]
+                                    return [text]
                                 return None
 
                         def _coerce_scalar(expected_type: Type[Any], val: Any) -> Tuple[bool, Optional[Any]]:
@@ -511,7 +517,48 @@ Today's date is {today}.
 
                         if valid_by_type:
                             if corrected_value is not None:
-                                setattr(cmd_parameters, field_name, corrected_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", [])
+                                    #     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
+
+                                    # 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 ""
+
+                                        invalid_fields.append(f"{field_name} '{field_value}'")
+                                        all_suggestions[field_name] = [f"Please use the format matching pattern {pattern_str} (e.g., {example})"]
+                                        is_valid = False
+                                    else:
+                                        try:
+                                            setattr(cmd_parameters, field_name, corrected_value)
+                                        except Exception as e:
+                                            logger.critical(f"Failed to set attribute {field_name} with value {corrected_value}")
+                                            raise e
+                                else:
+                                    try:
+                                        setattr(cmd_parameters, field_name, corrected_value)
+                                    except Exception as e:
+                                        logger.critical(f"Failed to set attribute {field_name} with value {corrected_value}")
+                                        raise e
                         else:
                             invalid_fields.append(f"{field_name} '{field_value}'")
                             all_suggestions[field_name] = build_type_suggestion()
@@ -539,35 +586,6 @@ Today's date is {today}.
                     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
-
-                    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)