fastworkflow 2.15.13__py3-none-any.whl → 2.16.0__py3-none-any.whl

fastworkflow/_workflows/command_metadata_extraction/_commands/IntentDetection/what_can_i_do.py

@@ -148,11 +148,20 @@ class ResponseGenerator:
             for_agents=is_agent_mode,
         )
 
+        # Check if the NLU pipeline stage is intent detection
+        success = False
+        nlu_pipeline_stage = workflow.context.get(
+            "NLU_Pipeline_Stage", 
+            fastworkflow.NLUPipelineStage.INTENT_DETECTION)
+        if nlu_pipeline_stage == fastworkflow.NLUPipelineStage.INTENT_DETECTION:
+            success = True
+
         return fastworkflow.CommandOutput(
             workflow_id=workflow.id,
             command_responses=[
                 fastworkflow.CommandResponse(
                     response=response,
+                    success=success
                 )
             ]
         ) 

fastworkflow/_workflows/command_metadata_extraction/_commands/wildcard.py

@@ -67,7 +67,10 @@ class ResponseGenerator:
             if cnp_output.command_name == 'ErrorCorrection/you_misunderstood':
                 workflow_context["NLU_Pipeline_Stage"] = NLUPipelineStage.INTENT_MISUNDERSTANDING_CLARIFICATION
                 workflow_context["command"] = command
-            else:
+            elif (
+                nlu_pipeline_stage == fastworkflow.NLUPipelineStage.INTENT_DETECTION or
+                cnp_output.command_name == 'ErrorCorrection/abort'
+            ):
                 workflow.end_command_processing()
             workflow.context = workflow_context
 
@@ -76,9 +79,13 @@ class ResponseGenerator:
                 command=command,
             )
             command_output = CommandExecutor.perform_action(workflow, startup_action)
-            command_output.command_responses[0].artifacts["command_handled"] = True     
-            # Set the additional attributes
-            command_output.command_name = cnp_output.command_name
+            if (
+                nlu_pipeline_stage == fastworkflow.NLUPipelineStage.INTENT_DETECTION or
+                cnp_output.command_name == 'ErrorCorrection/abort'
+            ):
+                command_output.command_responses[0].artifacts["command_handled"] = True     
+                # Set the additional attributes
+                command_output.command_name = cnp_output.command_name
             return command_output
         
         if nlu_pipeline_stage in {
@@ -138,7 +145,9 @@ class ResponseGenerator:
             workflow.context = workflow_context
 
         command_name = cnp_output.command_name
-        extractor = ParameterExtraction(workflow, app_workflow, command_name, command)
+        # Use the preserved original command (with parameters) if available
+        preserved_command = f'{command_name}: {workflow.context.get("command", command)}'
+        extractor = ParameterExtraction(workflow, app_workflow, command_name, preserved_command)
         pe_output = extractor.extract()
         if not pe_output.parameters_are_valid:
             return CommandOutput(
@@ -161,7 +170,7 @@ class ResponseGenerator:
                 CommandResponse(
                     response="",
                     artifacts={
-                        "command": command,
+                        "command": preserved_command,
                         "command_name": command_name,
                         "cmd_parameters": pe_output.cmd_parameters,
                     },

fastworkflow/_workflows/command_metadata_extraction/intent_detection.py

@@ -136,7 +136,7 @@ class CommandNamePrediction:
             NLUPipelineStage.INTENT_AMBIGUITY_CLARIFICATION,
             NLUPipelineStage.INTENT_MISUNDERSTANDING_CLARIFICATION
         ) and not command_name:
-            command_name = "what_can_i_do"
+            command_name = "what can i do?"
 
         if not command_name or command_name == "wildcard":
             fully_qualified_command_name=None

fastworkflow/chat_session.py

@@ -35,7 +35,7 @@ class ChatWorker(Thread):
         """Process messages for the root workflow"""
         try:
             self.chat_session._status = SessionStatus.RUNNING
-            workflow = ChatSession.get_active_workflow()
+            workflow = self.chat_session.get_active_workflow()
             logger.debug(f"Started root workflow {workflow.id}")
             
             # Run the workflow loop
@@ -44,39 +44,34 @@ class ChatWorker(Thread):
         finally:
             self.chat_session._status = SessionStatus.STOPPED
             # Ensure workflow is popped if thread terminates unexpectedly
-            if ChatSession.get_active_workflow() is not None:
-                ChatSession.pop_active_workflow()
+            if self.chat_session.get_active_workflow() is not None:
+                self.chat_session.pop_active_workflow()
 
 class ChatSession:
-    _workflow_stack_lock = Lock()
-    _workflow_stack: ClassVar[deque[fastworkflow.Workflow]] = deque()  # Stack of workflow objects
-    
-    @classmethod
-    def get_active_workflow(cls) -> Optional[fastworkflow.Workflow]:
+    def get_active_workflow(self) -> Optional[fastworkflow.Workflow]:
         """Get the currently active workflow (top of stack)"""
-        with cls._workflow_stack_lock:
-            return cls._workflow_stack[-1] if cls._workflow_stack else None
+        with self._workflow_stack_lock:
+            return self._workflow_stack[-1] if self._workflow_stack else None
     
-    @classmethod
-    def push_active_workflow(cls, workflow: fastworkflow.Workflow) -> None:
-        with cls._workflow_stack_lock:
-            cls._workflow_stack.append(workflow)
-            logger.debug(f"Workflow stack: {[w.id for w in cls._workflow_stack]}")
+    def push_active_workflow(self, workflow: fastworkflow.Workflow) -> None:
+        """Push a workflow onto this session's stack"""
+        with self._workflow_stack_lock:
+            self._workflow_stack.append(workflow)
+            logger.debug(f"Workflow stack: {[w.id for w in self._workflow_stack]}")
     
-    @classmethod
-    def pop_active_workflow(cls) -> Optional[fastworkflow.Workflow]:
-        with cls._workflow_stack_lock:
-            if not cls._workflow_stack:
+    def pop_active_workflow(self) -> Optional[fastworkflow.Workflow]:
+        """Pop a workflow from this session's stack"""
+        with self._workflow_stack_lock:
+            if not self._workflow_stack:
                 return None
-            workflow = cls._workflow_stack.pop()
-            logger.debug(f"Workflow stack after pop: {[w.id for w in cls._workflow_stack]}")
+            workflow = self._workflow_stack.pop()
+            logger.debug(f"Workflow stack after pop: {[w.id for w in self._workflow_stack]}")
             return workflow
 
-    @classmethod
-    def clear_workflow_stack(cls) -> None:
-        """Clear the entire workflow stack"""
-        with cls._workflow_stack_lock:
-            cls._workflow_stack.clear()
+    def clear_workflow_stack(self) -> None:
+        """Clear the entire workflow stack for this session"""
+        with self._workflow_stack_lock:
+            self._workflow_stack.clear()
             logger.debug("Workflow stack cleared")
 
     def stop_workflow(self) -> None:
@@ -95,7 +90,7 @@ class ChatSession:
                 logger.warning("Chat worker thread did not terminate within timeout")
         
         # Clear the workflow stack
-        ChatSession.clear_workflow_stack()
+        self.clear_workflow_stack()
         
         # Reset status to stopped
         self._status = SessionStatus.STOPPED
@@ -116,6 +111,10 @@ class ChatSession:
         A chat session can run multiple workflows that share the same message queues.
         Use start_workflow() to start a specific workflow within this session.
         """
+        # Create instance-level workflow stack (supports nested workflows within this session)
+        self._workflow_stack: deque[fastworkflow.Workflow] = deque()
+        self._workflow_stack_lock = Lock()
+        
         # Create queues for user messages and command outputs
         self._user_message_queue = Queue()
         self._command_output_queue = Queue()
@@ -197,7 +196,7 @@ class ChatSession:
 
         # Check if we need to stop the current workflow
         # Stop if this is a new root workflow (no parent, keep_alive=True)
-        current_workflow = ChatSession.get_active_workflow()
+        current_workflow = self.get_active_workflow()
         if (current_workflow and 
             parent_workflow_id is None and 
             self._keep_alive):
@@ -244,7 +243,7 @@ class ChatSession:
         self._status = SessionStatus.STARTING
         
         # Push this workflow as active
-        ChatSession.push_active_workflow(workflow)
+        self.push_active_workflow(workflow)
         
         # Initialize workflow tool agent if in agent mode
         # This must happen after pushing the workflow to the stack
@@ -304,12 +303,12 @@ class ChatSession:
 
     @property
     def workflow_is_complete(self) -> bool:
-        workflow = ChatSession.get_active_workflow()
+        workflow = self.get_active_workflow()
         return workflow.is_complete if workflow else True
     
     @workflow_is_complete.setter
     def workflow_is_complete(self, value: bool) -> None:
-        if workflow := ChatSession.get_active_workflow():
+        if workflow := self.get_active_workflow():
             workflow.is_complete = value
     
     @property
@@ -317,21 +316,22 @@ class ChatSession:
         """Return the conversation history."""
         return self._conversation_history
 
-    def clear_conversation_history(self, trace_filename_suffix: Optional[str] = None) -> None:
+    # def clear_conversation_history(self, trace_filename_suffix: Optional[str] = None) -> None:
+    def clear_conversation_history(self) -> None:
         """
         Clear the conversation history.
         This resets the conversation history to an empty state.
         """
         self._conversation_history = dspy.History(messages=[])
         # Filename for conversation traces
-        if trace_filename_suffix:
-            self._conversation_traces_file_name: str = (
-                f"conversation_traces_{trace_filename_suffix}"
-            )
-        else:
-            self._conversation_traces_file_name: str = (
-                f"conversation_traces_{datetime.now().strftime('%m_%d_%Y:%H_%M_%S')}.jsonl"
-            )
+        # if trace_filename_suffix:
+        #     self._conversation_traces_file_name: str = (
+        #         f"conversation_traces_{trace_filename_suffix}"
+        #     )
+        # else:
+        #     self._conversation_traces_file_name: str = (
+        #         f"conversation_traces_{datetime.now().strftime('%m_%d_%Y:%H_%M_%S')}.jsonl"
+        #     )
 
     def _run_workflow_loop(self) -> Optional[fastworkflow.CommandOutput]:
         """
@@ -341,7 +341,7 @@ class ChatSession:
         - All outputs (success or failure) are sent to queue during processing
         """
         last_output = None
-        workflow = ChatSession.get_active_workflow()
+        workflow = self.get_active_workflow()
 
         try:
             # Handle startup command/action
@@ -385,7 +385,7 @@ class ChatSession:
 
         finally:
             self._status = SessionStatus.STOPPED
-            ChatSession.pop_active_workflow()
+            self.pop_active_workflow()
             logger.debug(f"Workflow {workflow.id if workflow else 'unknown'} completed")
 
         return None
@@ -401,7 +401,7 @@ class ChatSession:
     # def _process_mcp_tool_call(self, message: str) -> fastworkflow.CommandOutput:
     #     # sourcery skip: class-extract-method, extract-method
     #     """Process an MCP tool call message"""
-    #     workflow = ChatSession.get_active_workflow()
+    #     workflow = self.get_active_workflow()
         
     #     try:
     #         # Parse JSON message
@@ -429,7 +429,7 @@ class ChatSession:
     #             self.command_output_queue.put(command_output)
 
     #         # Flush on successful or failed tool call – state may have changed.
-    #         if workflow := ChatSession.get_active_workflow():
+    #         if workflow := self.get_active_workflow():
     #             workflow.flush()
             
     #         return command_output
@@ -500,11 +500,15 @@ class ChatSession:
         if os.path.exists("action.jsonl"):
             with open("action.jsonl", "r", encoding="utf-8") as f:
                 actions = [json.loads(line) for line in f if line.strip()]
-            conversation_summary = self._extract_conversation_summary(message, actions, result_text)
+            conversation_summary, conversation_traces = self._extract_conversation_summary(message, actions, result_text)
             command_response.artifacts["conversation_summary"] = conversation_summary
 
         self.conversation_history.messages.append(
-            {f"conversation {len(self.conversation_history.messages) + 1}": conversation_summary}
+            {
+                "conversation summary": conversation_summary,
+                "conversation_traces": conversation_traces,
+                "feedback": None  # Initialize feedback slot for this turn
+            }
         )
 
         command_output = fastworkflow.CommandOutput(
@@ -514,11 +518,11 @@ class ChatSession:
 
         # Put output in queue (following same pattern as _process_message)
         if (not command_output.success or self._keep_alive) and \
-                self.command_output_queue:
+                    self.command_output_queue:
             self.command_output_queue.put(command_output)
 
         # Persist workflow state changes
-        if workflow := ChatSession.get_active_workflow():
+        if workflow := self.get_active_workflow():
             workflow.flush()
 
         return command_output
@@ -529,20 +533,77 @@ class ChatSession:
         # command_output = self.profile_invoke_command(message)
         
         command_output = self._CommandExecutor.invoke_command(self, message)
+
+        # Record assistant mode trace to action.jsonl (similar to agent mode in workflow_agent.py)
+        # This ensures assistant commands are captured even when interspersed with agent commands
+        response_text = ""
+        if command_output.command_responses:
+            response_text = command_output.command_responses[0].response or ""
+        
+        # Convert parameters to dict if it's a Pydantic model or other complex object
+        params = command_output.command_parameters or {}
+        if hasattr(params, 'model_dump'):
+            params = params.model_dump()
+        elif hasattr(params, 'dict'):
+            params = params.dict()
+        
+        record = {
+            "command": message,
+            "command_name": command_output.command_name or "",
+            "parameters": params,
+            "response": response_text
+        }
+
+        self.conversation_history.messages.append(
+            {
+                "conversation summary": "assistant_mode_command",
+                "conversation_traces": json.dumps(record),
+                "feedback": None  # Initialize feedback slot for this turn
+            }
+        )
+
         if (not command_output.success or self._keep_alive) and \
             self.command_output_queue:
             self.command_output_queue.put(command_output)
 
         # Persist workflow state changes lazily accumulated during message processing.
-        if workflow := ChatSession.get_active_workflow():
+        if workflow := self.get_active_workflow():
             workflow.flush()
 
         return command_output
 
     def _process_action(self, action: fastworkflow.Action) -> fastworkflow.CommandOutput:
         """Process a startup action"""
-        workflow = ChatSession.get_active_workflow()
+        workflow = self.get_active_workflow()
         command_output = self._CommandExecutor.perform_action(workflow, action)
+
+        # Record action trace to action.jsonl
+        response_text = ""
+        if command_output.command_responses:
+            response_text = command_output.command_responses[0].response or ""
+        
+        # Convert parameters to dict if it's a Pydantic model or other complex object
+        params = action.parameters or {}
+        if hasattr(params, 'model_dump'):
+            params = params.model_dump()
+        elif hasattr(params, 'dict'):
+            params = params.dict()
+        
+        record = {
+            "command": "process_action",
+            "command_name": action.command_name,
+            "parameters": params,
+            "response": response_text
+        }
+
+        self.conversation_history.messages.append(
+            {
+                "conversation summary": "process_action command",
+                "conversation_traces": json.dumps(record),
+                "feedback": None  # Initialize feedback slot for this turn
+            }
+        )
+
         if (not command_output.success or self._keep_alive) and \
             self.command_output_queue:
             self.command_output_queue.put(command_output)
@@ -573,15 +634,16 @@ class ChatSession:
         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.
+        Returns the conversation summary and the log entry
         """
         # Lets log everything to a file called action_log.jsonl, if it exists
-        log_entry = {
+        conversation_traces = {
             "user_query": user_query,
             "agent_workflow_interactions": workflow_actions,
             "final_agent_response": final_agent_response
         }
-        with open(self._conversation_traces_file_name, "a", encoding="utf-8") as f:
-            f.write(json.dumps(log_entry) + "\n")
+        # with open(self._conversation_traces_file_name, "a", encoding="utf-8") as f:
+        #     f.write(json.dumps(log_entry) + "\n")
 
         class ConversationSummarySignature(dspy.Signature):
             """
@@ -601,7 +663,7 @@ class ChatSession:
                 user_query=user_query, 
                 workflow_actions=workflow_actions, 
                 final_agent_response=final_agent_response)
-            return prediction.conversation_summary
+            return prediction.conversation_summary, json.dumps(conversation_traces)
 
     
     def profile_invoke_command(self, message: str):

fastworkflow/command_executor.py

@@ -56,7 +56,7 @@ class CommandExecutor(CommandExecutorInterface):
         command_name = command_output.command_responses[0].artifacts["command_name"]
         input_obj = command_output.command_responses[0].artifacts["cmd_parameters"]
 
-        workflow = ChatSession.get_active_workflow()
+        workflow = chat_session.get_active_workflow()
         workflow_name = workflow.folderpath.split('/')[-1]
         context = workflow.current_command_context_displayname
 

fastworkflow/examples/fastworkflow.env

@@ -3,6 +3,7 @@ LLM_PARAM_EXTRACTION=mistral/mistral-small-latest
 LLM_RESPONSE_GEN=mistral/mistral-small-latest
 LLM_PLANNER=mistral/mistral-small-latest
 LLM_AGENT=mistral/mistral-small-latest
+LLM_CONVERSATION_STORE=mistral/mistral-small-latest
 
 SPEEDDICT_FOLDERNAME=___workflow_contexts
 SYNTHETIC_UTTERANCE_GEN_NUMOF_PERSONAS=4

fastworkflow/examples/fastworkflow.passwords.env

@@ -3,4 +3,5 @@ LITELLM_API_KEY_SYNDATA_GEN=<API KEY for synthetic data generation model>
 LITELLM_API_KEY_PARAM_EXTRACTION=<API KEY for parameter extraction model>
 LITELLM_API_KEY_RESPONSE_GEN=<API KEY for response generation model>
 LITELLM_API_KEY_PLANNER=<API KEY for the agent's task planner model>
-LITELLM_API_KEY_AGENT=<API KEY for the agent model>
+LITELLM_API_KEY_AGENT=<API KEY for the agent model>
+LITELLM_API_KEY_CONVERSATION_STORE=<API KEY for conversation topic/summary generation model>

fastworkflow/mcp_server.py

@@ -41,7 +41,7 @@ class FastWorkflowMCPServer:
         NOT_FOUND = fastworkflow.get_env_var('NOT_FOUND')
 
         # Get available commands from workflow
-        workflow = fastworkflow.ChatSession.get_active_workflow()
+        workflow = fastworkflow.chat_session.get_active_workflow()
         workflow_folderpath = workflow.folderpath
         # Use cached routing definition instead of rebuilding every time
         routing = RoutingRegistry.get_definition(workflow_folderpath)
@@ -147,7 +147,7 @@ class FastWorkflowMCPServer:
             arguments=arguments
         )
         
-        workflow = fastworkflow.ChatSession.get_active_workflow()
+        workflow = fastworkflow.chat_session.get_active_workflow()
         # Execute using MCP-compliant method
         return CommandExecutor.perform_mcp_tool_call(
             workflow,
@@ -203,7 +203,7 @@ class FastWorkflowMCPServer:
 
         Falls back to the first available path if the active context is none.
         """
-        workflow = fastworkflow.ChatSession.get_active_workflow()
+        workflow = fastworkflow.chat_session.get_active_workflow()
         return workflow.current_command_context_name
 
 

fastworkflow/workflow_agent.py

@@ -174,8 +174,9 @@ def _ask_user_tool(clarification_request: str, chat_session_obj: fastworkflow.Ch
     Note that using the wrong command name can produce missing information errors. Double-check with the missing_information_guidance_tool to verify that the correct command name is being used 
     """
     command_output = fastworkflow.CommandOutput(
-        command_responses=[fastworkflow.CommandResponse(response=clarification_request)]
-    )
+        command_responses=[fastworkflow.CommandResponse(response=clarification_request)],
+        workflow_name = chat_session_obj.get_active_workflow().folderpath.split('/')[-1]
+    )    
     chat_session_obj.command_output_queue.put(command_output)
 
     user_query = chat_session_obj.user_message_queue.get()

{fastworkflow-2.15.13.dist-info → fastworkflow-2.16.0.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: fastworkflow
-Version: 2.15.13
+Version: 2.16.0
 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
 Author: Dhar Rawal
 Author-email: drawal@radiantlogic.com
-Requires-Python: >=3.11
+Requires-Python: >=3.11,<3.14
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
@@ -581,6 +581,7 @@ This single command will generate the `greet.py` command, `get_properties` and `
 | `LLM_RESPONSE_GEN` | LiteLLM model string for response generation | `run` | `mistral/mistral-small-latest` |
 | `LLM_PLANNER` | LiteLLM model string for the agent's task planner | `run` (agent mode) | `mistral/mistral-small-latest` |
 | `LLM_AGENT` | LiteLLM model string for the DSPy agent | `run` (agent mode) | `mistral/mistral-small-latest` |
+| `LLM_CONVERSATION_STORE` | LiteLLM model string for conversation topic/summary generation | FastAPI service | `mistral/mistral-small-latest` |
 | `NOT_FOUND` | Placeholder value for missing parameters during extraction | Always | `"NOT_FOUND"` |
 | `MISSING_INFORMATION_ERRMSG` | Error message prefix for missing parameters | Always | `"Missing required..."` |
 | `INVALID_INFORMATION_ERRMSG` | Error message prefix for invalid parameters | Always | `"Invalid information..."` |
@@ -594,6 +595,7 @@ This single command will generate the `greet.py` command, `get_properties` and `
 | `LITELLM_API_KEY_RESPONSE_GEN`| API key for the `LLM_RESPONSE_GEN` model | `run` | *required* |
 | `LITELLM_API_KEY_PLANNER`| API key for the `LLM_PLANNER` model | `run` (agent mode) | *required* |
 | `LITELLM_API_KEY_AGENT`| API key for the `LLM_AGENT` model | `run` (agent mode) | *required* |
+| `LITELLM_API_KEY_CONVERSATION_STORE`| API key for the `LLM_CONVERSATION_STORE` model | FastAPI service | *required* |
 
 > [!tip]
 > The example workflows are configured to use Mistral's models by default. You can get a free API key from [Mistral AI](https://mistral.ai) that works with the `mistral-small-latest` model.

{fastworkflow-2.15.13.dist-info → fastworkflow-2.16.0.dist-info}/RECORD

@@ -7,12 +7,12 @@ fastworkflow/_workflows/command_metadata_extraction/_commands/ErrorCorrection/ab
 fastworkflow/_workflows/command_metadata_extraction/_commands/ErrorCorrection/you_misunderstood.py,sha256=VHfhwlqc1ceG9P_wL8Fl7dpJA2UlcSrcXhz7zZU9NpA,2517
 fastworkflow/_workflows/command_metadata_extraction/_commands/IntentDetection/go_up.py,sha256=K526OAf5ks95SwqVdRNVxLM_AWDfA1qXbkNYq0dANwg,1889
 fastworkflow/_workflows/command_metadata_extraction/_commands/IntentDetection/reset_context.py,sha256=xvInu6uDw0YRUHVXNyTZphSr75f8QiQgFwDtv7SlE9o,1346
-fastworkflow/_workflows/command_metadata_extraction/_commands/IntentDetection/what_can_i_do.py,sha256=Fw8tsk3wyCujf8nBfUgPDxnTP9c2IE513FzqAWGm8pU,6216
+fastworkflow/_workflows/command_metadata_extraction/_commands/IntentDetection/what_can_i_do.py,sha256=9I9Y1VRvmiqft7vkz_8gGgCYTesMzBvP58wef3sjLZM,6593
 fastworkflow/_workflows/command_metadata_extraction/_commands/IntentDetection/what_is_current_context.py,sha256=S5RQLr62Q2MnKU85nw4IW_ueAK_FXvhcY9gXajFxujg,1464
 fastworkflow/_workflows/command_metadata_extraction/_commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastworkflow/_workflows/command_metadata_extraction/_commands/wildcard.py,sha256=TphAB_rwR7giCx00hovGZ2p9Qh-q1VAOZQNJF0DjRJY,7287
+fastworkflow/_workflows/command_metadata_extraction/_commands/wildcard.py,sha256=Sqpc2hwM-DgmsqiHu3OoOuqo3XnHLkFlmyYCJA8nj_8,7843
 fastworkflow/_workflows/command_metadata_extraction/command_context_model.json,sha256=zGWBweQSmFf7WsfR_F2DE7AJ8S8-q7F9ZbvyccysJJI,117
-fastworkflow/_workflows/command_metadata_extraction/intent_detection.py,sha256=A0vzyHGMtBEWCzfTU_I9tnRx2Byu-ElJgfMugRlXkpA,14542
+fastworkflow/_workflows/command_metadata_extraction/intent_detection.py,sha256=Ci0Cut_rH8wpUlLEsTMK-OhT3AO2nKgJmXQYIsoTzJw,14543
 fastworkflow/_workflows/command_metadata_extraction/parameter_extraction.py,sha256=MgNkPgA05E1-LSw9pNKDlXdsAphulYNhuDeTTqk5dBY,13686
 fastworkflow/build/__main__.py,sha256=NtedkZfM56qoEJ5vQECSURbE8AMTfwHN3tAZyZoWabk,15905
 fastworkflow/build/ast_class_extractor.py,sha256=F9OG4stkp7w3kadKqxMm8h3ZDSp_zg6mwcrKMl_XqdI,13527
@@ -35,11 +35,11 @@ fastworkflow/build/navigator_stub_generator.py,sha256=_DSvHC6r1xWQiFHtUgPhI51nQf
 fastworkflow/build/pydantic_model_generator.py,sha256=oNyoANyUWBpHG-fE3tGL911RNvDzQXjxAm0ssvuXUH4,1854
 fastworkflow/build/utterance_generator.py,sha256=UrtkF0wyAZ1hiFitHX0g8w7Wh-D0leLCrP1aUACSfHo,299
 fastworkflow/cache_matching.py,sha256=OoB--1tO6-O4BKCuCrUbB0CkUr76J62K4VAf6MShi-w,7984
-fastworkflow/chat_session.py,sha256=Nm0RZyaCxiFODlyh4s2fWY8uBQVwYbUVl7ThgJvdWwA,29044
+fastworkflow/chat_session.py,sha256=p8n2rQx3mhZ_DoRb14sRbp0PGKidMS6H2wwC1TNPxnM,31592
 fastworkflow/cli.py,sha256=li9OFT05sxqz4BZJc9byKAeTmomjLfsWMVuy0OiRGSs,18953
 fastworkflow/command_context_model.py,sha256=nWxLP3TR7WJr3yWCedqcdFOxo_kwae_mS3VRN2cOmK8,13437
 fastworkflow/command_directory.py,sha256=aJ6UQCwevfF11KbcQB2Qz6mQ7Kj91pZtvHmQY6JFnao,29030
-fastworkflow/command_executor.py,sha256=UGM6JpOoZOYR3cbLOOLN3oziwNvUH-Cm-d1XFRzbW7k,8456
+fastworkflow/command_executor.py,sha256=WTSrukv6UDQfWUDSNleIQ1TxwDnAQIKIimh4sQVwnig,8457
 fastworkflow/command_interfaces.py,sha256=PWIKlcp0G8nmYl0vkrg1o6QzJL0pxXkfrn1joqTa0eU,460
 fastworkflow/command_metadata_api.py,sha256=KtidE3PM9HYfY-nmEXZ8Y4nnaw2qn23p_gvwFVT3F8Y,39770
 fastworkflow/command_routing.py,sha256=R7194pcY0d2VHzmCu9ALacm1UvNuIRIvTn8mLp-EZIM,17219
@@ -50,8 +50,8 @@ fastworkflow/examples/extended_workflow_example/_commands/generate_report.py,sha
 fastworkflow/examples/extended_workflow_example/_commands/startup.py,sha256=V5Q29148SvXw6i3i0pKTuNWsv2xnkUMsHHuzt1ndxro,1028
 fastworkflow/examples/extended_workflow_example/simple_workflow_template.json,sha256=A-dAl5iD9ehdMGGn05O2Kjwq6ZetqQjAGzlM1st0K9U,1237
 fastworkflow/examples/extended_workflow_example/workflow_inheritance_model.json,sha256=TBk272pqfyRKzm4T-I6_nGfbcdmEzjwon7kFPWtgyhw,81
-fastworkflow/examples/fastworkflow.env,sha256=FNx41woSsG7ljcwI6H6Y3RCMw6mXiImcq8QMnqeqSao,623
-fastworkflow/examples/fastworkflow.passwords.env,sha256=CJemqCpj8HeSznTFUfCSc6I5r8noXuRWKfkrHaslD7E,424
+fastworkflow/examples/fastworkflow.env,sha256=mLI1fWqkzjcp9uzfHw81mlOx4JFb8Ch_TBy8dX1Dsok,675
+fastworkflow/examples/fastworkflow.passwords.env,sha256=9bI62EokFWT_YPcO0UAvO1ZTG2wM76Jbe5cKE7_KTRg,517
 fastworkflow/examples/hello_world/_commands/README.md,sha256=pYOTGqVx41ZIuNc6hPTEJzNcMQ2Vwx3PN74ifSlayvU,1297
 fastworkflow/examples/hello_world/_commands/add_two_numbers.py,sha256=0lFGK1llT6u6fByvzCDPdegjY6gWcerM2cvxVSo7lIw,2232
 fastworkflow/examples/hello_world/_commands/context_inheritance_model.json,sha256=RBNvo1WzZ4oRRq0W9-hknpT7T8If536DEMBg9hyq_4o,2
@@ -140,14 +140,11 @@ fastworkflow/examples/simple_workflow_template/application/__init__.py,sha256=47
 fastworkflow/examples/simple_workflow_template/application/workitem.py,sha256=Sm-QoX-EZvynkNf7uO3dViZF2VZqUlr6PAZZ7yjQEfk,40197
 fastworkflow/examples/simple_workflow_template/simple_workflow_template.json,sha256=A-dAl5iD9ehdMGGn05O2Kjwq6ZetqQjAGzlM1st0K9U,1237
 fastworkflow/examples/simple_workflow_template/startup_action.json,sha256=gj0-B4CqTYCs8OwHKhTu95H4uZbLsDf1th06IFfNXVs,75
-fastworkflow/mcp_server.py,sha256=f6vqHiG-cuMpeoeRY-mvsFxApmQ28cAJFfMtqoJYy5k,8864
+fastworkflow/mcp_server.py,sha256=NxbLSKf2MA4lAHVcm6ZfiVuOjVO6IeV5Iw17wImFbxQ,8867
 fastworkflow/model_pipeline_training.py,sha256=P_9wrYSfJVSYCTu8VEPkgXJ16eH58LLCK4rCRbRFAVg,46740
 fastworkflow/refine/__main__.py,sha256=bDLpPNMcdp8U4EFnMdjxx1sPDQCZuEJoBURr2KebTng,3398
 fastworkflow/run/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastworkflow/run/__main__.py,sha256=e3gTjcQwYuEz12LZIdL5w48aMRJ-42MdlyapINj7XWk,12430
-fastworkflow/run_agent/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fastworkflow/run_agent/__main__.py,sha256=japXWziVDHdLl7Hk-jzwcYkImVY4j4k9SodMhiRK3ow,11986
-fastworkflow/run_agent/agent_module.py,sha256=XbOfX2K2CwmIRT45YtoROCN4en9Ud8gMQh2kGEhqw_A,8012
 fastworkflow/train/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 fastworkflow/train/__main__.py,sha256=AeGja42d0QhslQkxvDVigIluxxL7DYLdQPXYFOKQ7QA,8536
 fastworkflow/train/generate_synthetic.py,sha256=sTDk-E5ewkS4o-0LJeofiEv4uXGpqdGcFRYKY_Yf36Y,5322
@@ -169,10 +166,10 @@ fastworkflow/utils/react.py,sha256=HubwmM4H9UzLaLaeIkJseKCNMjyrOXvMZz-8sw4ycCE,1
 fastworkflow/utils/signatures.py,sha256=QOLX3j-AJkRWIkDhogbhxQo8MIt668xIKwd4SWiS2LY,31734
 fastworkflow/utils/startup_progress.py,sha256=9icSdnpFAxzIq0sUliGpNaH0Efvrt5lDtGfURV5BD98,3539
 fastworkflow/workflow.py,sha256=37gn7e3ct-gdGw43zS6Ab_ADoJJBO4eJW2PywfUpjEg,18825
-fastworkflow/workflow_agent.py,sha256=pwS-tZUsLFlOCmVxtmWzZ1b7iFmtlHBcCy3N0Hv06TA,16254
+fastworkflow/workflow_agent.py,sha256=-RXoHXH-vrEh6AWC6iYAwwR9CvaRynYuu-KrzOPCJbg,16348
 fastworkflow/workflow_inheritance_model.py,sha256=Pp-qSrQISgPfPjJVUfW84pc7HLmL2evuq0UVIYR51K0,7974
-fastworkflow-2.15.13.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-fastworkflow-2.15.13.dist-info/METADATA,sha256=Pb-rVYTCwlvQMEMxgJ-orQPFGO30UE_Vk6u6OTJhLYk,30066
-fastworkflow-2.15.13.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-fastworkflow-2.15.13.dist-info/entry_points.txt,sha256=m8HqoPzCyaZLAx-V5X8MJgw3Lx3GiPDlxNEZ7K-Gb-U,54
-fastworkflow-2.15.13.dist-info/RECORD,,
+fastworkflow-2.16.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+fastworkflow-2.16.0.dist-info/METADATA,sha256=Mno8E51bhYTFQ4P7YRzmd71rjOBm_niCOKnFsTGmJNs,30336
+fastworkflow-2.16.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+fastworkflow-2.16.0.dist-info/entry_points.txt,sha256=m8HqoPzCyaZLAx-V5X8MJgw3Lx3GiPDlxNEZ7K-Gb-U,54
+fastworkflow-2.16.0.dist-info/RECORD,,

fastworkflow/run_agent/__main__.py

@@ -1,294 +0,0 @@
-import argparse
-import contextlib
-import json
-import os
-import queue
-import time
-import threading
-from typing import Optional
-from dotenv import dotenv_values
-from queue import Empty
-
-import dspy
-
-
-# Instantiate a global console for consistent styling
-console = None
-
-def check_workflow_trained(workflow_path: str) -> bool:
-    """
-    Check if a workflow has been trained by looking for the tiny_ambiguous_threshold.json file
-    in the ___command_info/global folder.
-    
-    Args:
-        workflow_path: Path to the workflow folder
-    
-    Returns:
-        bool: True if the workflow appears to be trained, False otherwise
-    """
-    # Path to the global command info directory
-    global_cmd_info_path = os.path.join(workflow_path, "___command_info", "global")
-    
-    # Path to the tiny_ambiguous_threshold.json file
-    threshold_file_path = os.path.join(global_cmd_info_path, "tiny_ambiguous_threshold.json")
-    
-    # Check if the file exists
-    return os.path.exists(threshold_file_path)
-
-def main():
-    # Third-party CLI prettification libraries
-    from rich.console import Console
-    from rich.panel import Panel
-    from rich.table import Table
-    from rich.text import Text
-    from rich.console import Group
-    from prompt_toolkit import PromptSession
-    from prompt_toolkit.patch_stdout import patch_stdout
-
-
-    import fastworkflow
-    from fastworkflow.utils import dspy_utils
-    from fastworkflow.command_executor import CommandExecutor
-    from .agent_module import initialize_dspy_agent
-
-    # Progress bar helper
-    from fastworkflow.utils.startup_progress import StartupProgress
-
-    # Instantiate a global console for consistent styling
-    global console
-    console = Console()
-    prompt_session = PromptSession("User > ")
-
-    def _build_artifact_table(artifacts: dict[str, str]) -> Table:
-        """Return a rich.Table representation for artifact key-value pairs."""
-        table = Table(show_header=True, header_style="bold cyan", box=None)
-        table.add_column("Name", style="cyan", overflow="fold")
-        table.add_column("Value", style="white", overflow="fold")
-        for name, value in artifacts.items():
-            table.add_row(str(name), str(value))
-        return table
-
-    def print_command_output(command_output):
-        """Pretty-print workflow output using rich panels and tables."""
-        for command_response in command_output.command_responses:
-            workflow_id = "UnknownSession"
-            with contextlib.suppress(Exception):
-                workflow = fastworkflow.ChatSession.get_active_workflow()
-                workflow_id = workflow.id if workflow else "UnknownSession"
-
-            # Collect body elements for the panel content
-            body_renderables = []
-
-            if command_response.response:
-                body_renderables.append(Text(command_response.response, style="green"))
-
-            if command_response.artifacts:
-                body_renderables.extend(
-                    (
-                        Text("Artifacts", style="bold cyan"),
-                        _build_artifact_table(command_response.artifacts),
-                    )
-                )
-            if command_response.next_actions:
-                actions_table = Table(show_header=False, box=None)
-                for act in command_response.next_actions:
-                    actions_table.add_row(Text(str(act), style="blue"))
-                body_renderables.extend(
-                    (Text("Next Actions", style="bold blue"), actions_table)
-                )
-            if command_response.recommendations:
-                rec_table = Table(show_header=False, box=None)
-                for rec in command_response.recommendations:
-                    rec_table.add_row(Text(str(rec), style="magenta"))
-                body_renderables.extend(
-                    (Text("Recommendations", style="bold magenta"), rec_table)
-                )
-
-            panel_title = f"[bold yellow]Workflow {workflow_id}[/bold yellow]"
-            # Group all renderables together
-            group = Group(*body_renderables)
-            # Use the group in the panel
-            panel = Panel.fit(group, title=panel_title, border_style="green")
-            console.print(panel)
-
-    parser = argparse.ArgumentParser(description="AI Assistant for workflow processing")
-    parser.add_argument("workflow_path", help="Path to the workflow folder")
-    parser.add_argument("env_file_path", help="Path to the environment file")
-    parser.add_argument("passwords_file_path", help="Path to the passwords file")
-    parser.add_argument(
-        "--context_file_path", help="Optional context file path", default=""
-    )
-    parser.add_argument(
-        "--startup_command", help="Optional startup command", default=""
-    )
-    parser.add_argument(
-        "--startup_action", help="Optional startup action", default=""
-    )
-    parser.add_argument(
-        "--keep_alive", help="Optional keep_alive", default=True
-    )
-    parser.add_argument(
-        "--project_folderpath", help="Optional path to project folder containing application code", default=None
-    )
-
-    args = parser.parse_args()
-
-    if not os.path.isdir(args.workflow_path):
-        console.print(f"[bold red]Error:[/bold red] The specified workflow path '{args.workflow_path}' is not a valid directory.")
-        exit(1)
-
-    console.print(Panel(f"Running fastWorkflow: [bold]{args.workflow_path}[/bold]", title="[bold green]fastworkflow[/bold green]", border_style="green"))
-    console.print("[bold green]Tip:[/bold green] Type 'exit' to quit the application.")
-
-    # ------------------------------------------------------------------
-    # Startup progress bar ------------------------------------------------
-    # ------------------------------------------------------------------
-    command_info_root = os.path.join(args.workflow_path, "___command_info")
-    subdir_count = 0
-    if os.path.isdir(command_info_root):
-        subdir_count = len([d for d in os.listdir(command_info_root) if os.path.isdir(os.path.join(command_info_root, d))])
-
-    StartupProgress.begin(total=3)
-
-    StartupProgress.advance("Imported fastworkflow modules")
-
-    env_vars = {
-        **dotenv_values(args.env_file_path),
-        **dotenv_values(args.passwords_file_path)
-    }
-    StartupProgress.advance("fastworkflow.init complete")
-
-    fastworkflow.init(env_vars=env_vars)
-
-    LLM_AGENT = fastworkflow.get_env_var("LLM_AGENT")
-    if not LLM_AGENT:
-        console.print("[bold red]Error:[/bold red] DSPy Language Model not provided. Set LLM_AGENT environment variable.")
-        exit(1)
-
-    # Check if the workflow has been trained
-    if not check_workflow_trained(args.workflow_path):
-        # Extract workflow name for the error message
-        workflow_name = os.path.basename(args.workflow_path)
-        console.print(Panel(
-            f"To train this workflow, run:\n"
-            f"[bold white]fastworkflow train {args.workflow_path}[/bold white]",
-            title="[bold red]Workflow '{workflow_name}' has not been trained[/bold red]", 
-            border_style="red"
-        ))
-        exit(1)
-
-    # this could be None
-    lm = dspy_utils.get_lm("LLM_AGENT", "LITELLM_API_KEY_AGENT")
-
-    startup_action: Optional[fastworkflow.Action] = None
-    if args.startup_action:
-        with open(args.startup_action, 'r') as file:
-            startup_action_dict = json.load(file)
-        startup_action = fastworkflow.Action(**startup_action_dict)
-
-    context_dict = None
-    if args.context_file_path:
-        with open(args.context_file_path, 'r') as file:
-            context_dict = json.load(file)
-
-    # Create the chat session in agent mode
-    fastworkflow.chat_session = fastworkflow.ChatSession(run_as_agent=True)
-
-    # Start the workflow within the chat session
-    fastworkflow.chat_session.start_workflow(
-        args.workflow_path,
-        workflow_context=context_dict,
-        startup_command=args.startup_command, 
-        startup_action=startup_action, 
-        keep_alive=args.keep_alive,
-        project_folderpath=args.project_folderpath
-    )
-
-    StartupProgress.advance("ChatSession ready")
-    StartupProgress.end()
-
-    try:
-        react_agent = initialize_dspy_agent(fastworkflow.chat_session)
-    except (EnvironmentError, RuntimeError) as e:
-        console.print(f"[bold red]Failed to initialize DSPy agent:[/bold red] {e}")
-        exit(1)
-
-    with contextlib.suppress(queue.Empty):
-        if command_output := fastworkflow.chat_session.command_output_queue.get(
-            timeout=0.1
-        ):
-            console.print(Panel("Startup Command Output", border_style="dim"))
-            print_command_output(command_output)
-            console.print(Panel("End Startup Command Output", border_style="dim"))
-
-    while True: 
-        if not args.keep_alive and fastworkflow.chat_session.workflow_is_complete:
-            console.print("[blue]Workflow complete and keep_alive is false. Exiting...[/blue]")
-            break
-
-        with patch_stdout():
-            user_input_str = prompt_session.prompt()
-        if user_input_str.lower() == "exit":
-            console.print("[blue]User requested exit. Exiting...[/blue]")
-            break
-
-        try:
-            # Use a thread-safe way to store the agent response
-            agent_response_container = {"response": None, "error": None}
-
-            # Function to run agent processing in a separate thread
-            def process_agent_query():
-                try:
-                    with dspy.context(lm=lm):
-                        agent_response_container["response"] = react_agent(user_query=user_input_str)
-                except Exception as e:
-                    agent_response_container["error"] = e
-
-            # Start processing thread
-            agent_thread = threading.Thread(target=process_agent_query)
-            agent_thread.daemon = True
-            agent_thread.start()
-
-            # Queues used by the agent to request user clarification
-            from fastworkflow.run_agent.agent_module import (
-                clarification_request_queue,
-                clarification_response_queue,
-            )
-
-            with console.status("[bold cyan]Processing command...[/bold cyan]", spinner="dots") as status:
-                counter = 0
-                while agent_thread.is_alive():
-                    # Handle any number of clarification requests
-                    with contextlib.suppress(Empty):
-                        while True:
-                            prompt_text = clarification_request_queue.get_nowait()
-                            # Stop spinner so prompt renders cleanly
-                            status.stop()
-                            console.print(f"[bold yellow]Agent -> User> {prompt_text}[/bold yellow]")
-                            user_answer = prompt_session.prompt("User > ")
-                            clarification_response_queue.put(user_answer)
-                    time.sleep(0.3)
-                    counter += 1
-                    if counter % 3 == 0:
-                        status.update(
-                            f"[bold cyan]Processing command... ({counter // 3}s)[/bold cyan]"
-                        )
-
-                # Agent finished work
-                agent_thread.join()
-
-            # Check for errors or display response
-            if agent_response_container["error"]:
-                raise agent_response_container["error"]
-
-            if agent_response_container["response"]:
-                console.print(Panel(agent_response_container["response"].final_answer, 
-                                   title="[bold green]Agent Response[/bold green]", 
-                                   border_style="green"))
-
-        except Exception as e: # pylint: disable=broad-except
-            console.print(f"[bold red]Agent Error:[/bold red] An error occurred during agent processing: {e}")
-
-if __name__ == "__main__":
-    print("Loading fastWorkflow...\n")
-    main()

fastworkflow/run_agent/agent_module.py

@@ -1,194 +0,0 @@
-# fastworkflow/run_agent/agent_module.py
-"""
-High-level planning agent module for fastWorkflow.
-Uses the integrated workflow tool agent from ChatSession.
-"""
-import functools
-import os
-from queue import Queue
-from typing import Any, Optional, List, Dict
-
-import dspy
-from colorama import Fore, Style
-
-import fastworkflow
-from fastworkflow.mcp_server import FastWorkflowMCPServer
-
-# Queues used to synchronise clarification requests between the agent thread
-# (where `_ask_user_tool` is executed) and the main thread that owns the TTY.
-clarification_request_queue: Queue[str] = Queue()
-clarification_response_queue: Queue[str] = Queue()
-
-
-# DSPy Signature for the High-Level Planning Agent
-class PlanningAgentSignature(dspy.Signature):
-    """
-    Create a minimal step based todo list based only on the commands in the user query
-    Then, execute the plan for building the final answer using the WorkflowAssistant tool.
-    Double-check that all the tasks in the todo list have been completed before returning the final answer.
-    """
-    user_query = dspy.InputField(desc="The user's full input or question.")
-    final_answer = dspy.OutputField(desc="The agent's comprehensive response to the user after interacting with the workflow.")
-
-
-def _format_workflow_output_for_agent(command_output: Any) -> str:
-    """
-    Formats the structured CommandOutput from the workflow into a single string for the agent.
-    Handles both regular command responses and MCP tool results.
-    """
-    # Check if this is an MCP result converted to CommandOutput
-    if hasattr(command_output, '_mcp_source'):
-        return _format_mcp_result_for_agent(command_output._mcp_source)
-    
-    # Otherwise use existing logic for regular command responses
-    output_parts = []
-    if not hasattr(command_output, 'command_responses') or not command_output.command_responses:
-        return "Workflow produced no command responses or the response structure is unexpected."
-
-    for command_response in command_output.command_responses:
-        if response_text := getattr(command_response, 'response', None):
-            output_parts.append(f"{response_text}")
-
-        artifacts = getattr(command_response, 'artifacts', {})
-        output_parts.extend(
-            f"Artifact: {artifact_name}={artifact_value}"
-            for artifact_name, artifact_value in artifacts.items()
-        )
-        next_actions = getattr(command_response, 'next_actions', [])
-        output_parts.extend(f"Next Action: {action}" for action in next_actions)
-        
-        recommendations = getattr(command_response, 'recommendations', [])
-        output_parts.extend(
-            f"Recommendation: {recommendation}"
-            for recommendation in recommendations
-        )
-    
-    if not output_parts:
-        return "Workflow executed but produced no specific output, actions, or recommendations."
-    return "\n".join(output_parts)
-
-
-def _format_mcp_result_for_agent(mcp_result) -> str:
-    """Format MCPToolResult specifically for agent consumption"""
-    if mcp_result.isError:
-        return f"Error: {mcp_result.content[0].text}"
-    else:
-        return mcp_result.content[0].text
-
-
-def _build_assistant_tool_documentation(available_tools: List[Dict]) -> str:
-    """Build simplified tool documentation for the main agent's WorkflowAssistant tool."""
-
-    # Guidance for the MAIN AGENT on how to call WorkflowAssistant
-    main_agent_guidance = """
-    Use the WorkflowAssistant to interact with a suite of underlying tools to assist the user.
-    It takes a natural language query as input and delegates to an internal agent 
-    that will try to understand the request, select the most appropriate tool, and execute it.
-    In normal mode: Example tool_args: {"tool_request": "<A single tool request with tool description and all required input parameter names and values>"}
-    If workflow assistant reports back with parameter extraction errors: Example tool_args: {"tool_request": "<A strictly comma delimited list of just the requested parameter values>"}
-    
-    Available tools that WorkflowAssistant can access:
-    """
-
-    tool_docs = []
-    for tool_def in available_tools:
-        tool_name = tool_def['name']
-        tool_desc = tool_def['description'].split("\n")[0]
-
-        # Main agent does not need the detailed input schema, only name, description and parameters.
-        tool_docs.append(
-            f"\nTool Name: \"{tool_name}\""
-            f"\nDescription: {tool_desc}"
-            f"\nRequired Parameters: {tool_def['inputSchema']['required']}"
-        ) 
-
-    return main_agent_guidance + "\n".join(tool_docs)
-
-
-def _execute_workflow_command_tool_with_delegation(tool_request: str,
-                                                   *, 
-                                                   chat_session: fastworkflow.ChatSession,
-                                                   **kwargs) -> str:
-    """
-    Delegate tool requests to the workflow via queues.
-    This is used by the high-level planning agent in run_agent.
-    """
-    print(f"{Fore.CYAN}{Style.BRIGHT}Agent -> Workflow>{Style.RESET_ALL}{Fore.CYAN} {tool_request}{Style.RESET_ALL}")
-
-    if extras := " ".join(f"{k}={v}" for k, v in kwargs.items()):
-        # Send the request through the user message queue
-        chat_session.user_message_queue.put(f"{tool_request} {extras}")
-    else:
-        # Send the request through the user message queue
-        chat_session.user_message_queue.put(tool_request)
-
-    # Get the response from the command output queue
-    command_output = chat_session.command_output_queue.get()
-
-    # Format the output for the agent
-    result = _format_workflow_output_for_agent(command_output)
-
-    print(f"{Fore.BLUE}{Style.BRIGHT}Workflow -> Agent>{Style.RESET_ALL}{Fore.BLUE} {result.replace(os.linesep, ' ')}{Style.RESET_ALL}")
-    return result
-
-
-def _ask_user_tool(prompt: str) -> str:
-    """Request extra information from the human user.
-
-    Because the agent runs in a background thread, we cannot read from
-    `stdin` here.  Instead we send the prompt to the main thread via a
-    queue and block until the main thread puts the user's answer in the
-    response queue.
-    """
-    # Send the prompt to the main thread
-    clarification_request_queue.put(prompt)
-
-    return clarification_response_queue.get()
-
-
-def initialize_dspy_agent(chat_session: fastworkflow.ChatSession, max_iters: int = 25):
-    """
-    Configures and returns a high-level DSPy ReAct planning agent.
-    The workflow tool agent is already integrated in the ChatSession.
-    
-    Args:
-        chat_session: ChatSession instance (should be in agent mode)
-        max_iters: Maximum iterations for the ReAct agent
-    
-    Raises:
-        EnvironmentError: If LLM_AGENT is not set.
-    """
-    # Get available tools for documentation
-    mcp_server = FastWorkflowMCPServer(chat_session)
-    available_tools = mcp_server.list_tools()
-
-    # WorkflowAssistant Tool - delegates to the integrated workflow tool agent
-    _workflow_assistant_partial_func = functools.partial(
-        _execute_workflow_command_tool_with_delegation,
-        chat_session=chat_session
-    )
-    # Set the docstring for the partial object
-    _workflow_assistant_partial_func.__doc__ = _build_assistant_tool_documentation(available_tools)
-
-    workflow_assistant_instance = dspy.Tool(
-        name="WorkflowAssistant",
-        func=_workflow_assistant_partial_func
-    )
-
-    # AskUser Tool
-    _ask_user_tool.__doc__ = (
-        "Use this tool to get information from the user. "
-        "Use it as the last resort if information is not available via any of the other tools. "
-        "Args: prompt (str): A clear specific request with helpful context based on the information already gathered."
-    )
-
-    ask_user_instance = dspy.Tool(
-        name="AskUser",
-        func=_ask_user_tool
-    )
-
-    return dspy.ReAct(
-        PlanningAgentSignature,
-        tools=[workflow_assistant_instance, ask_user_instance],
-        max_iters=max_iters,
-    )