fastworkflow 2.17.8__tar.gz → 2.17.9__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastworkflow
-Version: 2.17.8
+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.8 → 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.8 → 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.8 → 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.8 → 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.8 → 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.8 → 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)
 

{fastworkflow-2.17.8 → fastworkflow-2.17.9}/fastworkflow/workflow_agent.py

@@ -99,10 +99,10 @@ def _execute_workflow_query(command: str, chat_session_obj: fastworkflow.ChatSes
     # Extract command name and parameters from command_output
     name = command_output.command_name
     params = command_output.command_parameters
-    
+
     # Handle parameter serialization
     params_dict = params.model_dump() if params else None
-    
+
     # Extract response text
     response_text = ""
     if command_output.command_responses:
@@ -135,8 +135,81 @@ def _execute_workflow_query(command: str, chat_session_obj: fastworkflow.ChatSes
     with open("action.jsonl", "a", encoding="utf-8") as f:
         f.write(json.dumps(record, ensure_ascii=False) + "\n")
 
-    if 'PARAMETER EXTRACTION ERROR' in response_text or 'The command is ambiguous' in response_text:
-        abort_confirmation = _execute_workflow_query('abort', chat_session_obj = chat_session_obj)
+    # Check workflow context to determine if we're in an error state that needs specialized handling
+    cme_workflow = chat_session_obj.cme_workflow
+    nlu_stage = cme_workflow.context.get("NLU_Pipeline_Stage")
+
+    # Handle intent ambiguity clarification state with specialized agent
+    if nlu_stage == fastworkflow.NLUPipelineStage.INTENT_AMBIGUITY_CLARIFICATION:
+        if intent_agent := chat_session_obj.intent_clarification_agent:
+            # Get suggested commands from intent detection system
+            from fastworkflow._workflows.command_metadata_extraction.intent_detection import CommandNamePrediction
+            predictor = CommandNamePrediction(cme_workflow)
+            suggested_commands = predictor._get_suggested_commands(predictor.path)
+
+            suggested_commands = list(suggested_commands) if suggested_commands is not None else []
+
+            # Get metadata for only the suggested commands
+            current_workflow = chat_session_obj.get_active_workflow()
+            suggested_commands_metadata = CommandMetadataAPI.get_suggested_commands_metadata(
+                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,
+                suggested_command_names=suggested_commands
+            )
+
+            # Get the workflow agent's trajectory and inputs for context
+            workflow_tool_agent = chat_session_obj.workflow_tool_agent
+            agent_inputs = workflow_tool_agent.inputs if workflow_tool_agent else {}
+            agent_trajectory = workflow_tool_agent.current_trajectory if workflow_tool_agent else {}
+
+            lm = dspy_utils.get_lm("LLM_AGENT", "LITELLM_API_KEY_AGENT")
+            with dspy.context(lm=lm):
+                result = intent_agent(
+                    original_command=command,
+                    error_message=response_text,
+                    agent_inputs=agent_inputs,
+                    agent_trajectory=agent_trajectory,
+                    suggested_commands_metadata=suggested_commands_metadata
+                )
+            # The clarified command should have the correct name with all original parameters
+            clarified_cmd = result.clarified_command if hasattr(result, 'clarified_command') else str(result)
+            # Execute the clarified command
+            return _execute_workflow_query(clarified_cmd, chat_session_obj=chat_session_obj)
+        else:
+            # No intent clarification agent available, fall back to abort
+            abort_confirmation = _execute_workflow_query('abort', chat_session_obj=chat_session_obj)
+            return f'{response_text}\n{abort_confirmation}'
+
+    # Handle intent misunderstanding clarification state with specialized agent
+    if nlu_stage == fastworkflow.NLUPipelineStage.INTENT_MISUNDERSTANDING_CLARIFICATION:
+        if intent_agent := chat_session_obj.intent_clarification_agent:
+            # Get the workflow agent's trajectory and inputs for context
+            workflow_tool_agent = chat_session_obj.workflow_tool_agent
+            agent_inputs = workflow_tool_agent.inputs if workflow_tool_agent else {}
+            agent_trajectory = workflow_tool_agent.current_trajectory if workflow_tool_agent else {}
+
+            lm = dspy_utils.get_lm("LLM_AGENT", "LITELLM_API_KEY_AGENT")
+            with dspy.context(lm=lm):
+                result = intent_agent(
+                    original_command=command,
+                    error_message=response_text,
+                    agent_inputs=agent_inputs,
+                    agent_trajectory=agent_trajectory,
+                    suggested_commands_metadata=""
+                )
+
+            clarified_cmd = result.clarified_command if hasattr(result, 'clarified_command') else str(result)
+
+            return _execute_workflow_query(clarified_cmd, chat_session_obj=chat_session_obj)
+        else:
+            # No intent clarification agent available, fall back to abort
+            abort_confirmation = _execute_workflow_query('abort', chat_session_obj=chat_session_obj)
+            return f'{response_text}\n{abort_confirmation}'
+
+    # Handle parameter extraction errors with abort
+    if nlu_stage == fastworkflow.NLUPipelineStage.PARAMETER_EXTRACTION:
+        abort_confirmation = _execute_workflow_query('abort', chat_session_obj=chat_session_obj)
         return f'{response_text}\n{abort_confirmation}'
 
     return response_text
@@ -253,6 +326,7 @@ def initialize_workflow_tool_agent(chat_session: fastworkflow.ChatSession, max_i
         The clarification_request must be plain text without any formatting.
         Note that using the wrong command name can produce missing information errors. Double-check with the what_can_i_do tool to verify that the correct command name is being used 
         """
+        chat_session_obj.workflow_tool_agent.iteration_counter = 0  # reset iteration counter, everytime we ask the user
         return _ask_user_tool(clarification_request, chat_session_obj=chat_session_obj)
 
     tools = [

{fastworkflow-2.17.8 → fastworkflow-2.17.9}/pyproject.toml

@@ -9,7 +9,7 @@ repository = "https://github.com/radiantlogicinc/fastworkflow"
 
 [tool.poetry]
 name = "fastworkflow"
-version = "2.17.8"
+version = "2.17.9"
 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"