fastworkflow 2.15.13__tar.gz → 2.17.0__tar.gz

{fastworkflow-2.15.13 → fastworkflow-2.17.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: fastworkflow
-Version: 2.15.13
+Version: 2.17.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 → fastworkflow-2.17.0}/README.md

@@ -548,6 +548,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..."` |
@@ -561,6 +562,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 → fastworkflow-2.17.0}/fastworkflow/_workflows/command_metadata_extraction/_commands/IntentDetection/what_can_i_do.py

@@ -8,6 +8,7 @@ import json
 
 import fastworkflow
 from fastworkflow.train.generate_synthetic import generate_diverse_utterances
+from fastworkflow.command_context_model import get_workflow_info
 from fastworkflow.command_metadata_api import CommandMetadataAPI
 
 class Signature:
@@ -139,20 +140,33 @@ class ResponseGenerator:
         with contextlib.suppress(Exception):
             if fastworkflow.chat_session:
                 is_agent_mode = fastworkflow.chat_session.run_as_agent
-        
+
         app_workflow = workflow.context["app_workflow"]
-        response = CommandMetadataAPI.get_command_display_text(
+        
+        # Get workflow definition
+        workflow_info = get_workflow_info(app_workflow.folderpath)
+        workflow_def_text = CommandMetadataAPI.get_workflow_definition_display_text(workflow_info)
+        
+        # Get available commands in current context
+        commands_text = CommandMetadataAPI.get_command_display_text(
             subject_workflow_path=app_workflow.folderpath,
             cme_workflow_path=workflow.folderpath,
             active_context_name=app_workflow.current_command_context_name,
             for_agents=is_agent_mode,
         )
+        
+        response = f"{workflow_def_text}\n\n{commands_text}"
 
+        nlu_pipeline_stage = workflow.context.get(
+            "NLU_Pipeline_Stage", 
+            fastworkflow.NLUPipelineStage.INTENT_DETECTION)
+        success = nlu_pipeline_stage == fastworkflow.NLUPipelineStage.INTENT_DETECTION
         return fastworkflow.CommandOutput(
             workflow_id=workflow.id,
             command_responses=[
                 fastworkflow.CommandResponse(
                     response=response,
+                    success=success
                 )
             ]
         ) 

{fastworkflow-2.15.13 → fastworkflow-2.17.0}/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-2.15.13 → fastworkflow-2.17.0}/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-2.15.13 → fastworkflow-2.17.0}/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
@@ -495,16 +495,21 @@ class ChatSession:
         # Create CommandOutput with the agent's response
         command_response = fastworkflow.CommandResponse(response=result_text)
 
+        conversation_traces = None
         conversation_summary = message
         # Attach actions captured during agent execution as artifacts if available
         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 +519,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 +534,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 +635,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 +664,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-2.15.13 → fastworkflow-2.17.0}/fastworkflow/command_context_model.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 import json
 from dataclasses import dataclass, field
+from typing import Any
+import os
 from pathlib import Path
-from typing import Any, Optional, Type
 
 import fastworkflow
-from fastworkflow.command_directory import CommandDirectory, get_cached_command_directory
+from fastworkflow.command_directory import get_cached_command_directory
 from fastworkflow.utils import python_utils
 
 """Utility for loading and traversing the single-file workflow command context model.
@@ -152,10 +153,10 @@ class CommandContextModel:
         hierarchy_model_path = Path(self._workflow_path) / "context_hierarchy_model.json"
         if not hierarchy_model_path.is_file():
             return {}
-        
+
         with hierarchy_model_path.open("r") as f:
             hierarchy_data = json.load(f)
-            
+
         return hierarchy_data
 
     def _resolve_ancestry(self, hierarchy: dict[str, dict[str, list[str]]]) -> None:
@@ -205,10 +206,10 @@ class CommandContextModel:
             all_ancestors.add(parent)
             grandparents = self.get_ancestor_contexts(parent, visiting.copy(), _hierarchy)
             all_ancestors.update(grandparents)
-        
+
         final_ancestors = sorted(list(all_ancestors))
         self._resolved_ancestors[context_name] = final_ancestors
-        
+
         visiting.remove(context_name)
 
         return final_ancestors
@@ -228,7 +229,7 @@ class CommandContextModel:
             # or by being part of a command inheritance structure. If it's not
             # in _command_contexts, it's an unknown/invalid context.
             raise CommandContextModelValidationError(f"Context '{context_name}' not found in model.")
-            
+
         if visiting is None:
             visiting = set()
 
@@ -294,3 +295,68 @@ class CommandContextModel:
             return getattr(module, context_metadata.context_class, None)
         else:
             return None
+
+
+# ---------------------------------------------------------------------
+# Workflow info helper (module-level)
+# ---------------------------------------------------------------------
+
+def get_workflow_info(chat_session_or_path: fastworkflow.ChatSession | str) -> dict[str, Any]:
+    """
+    Return workflow-level metadata for the active workflow in the given chat session or workflow path.
+
+    Shape:
+    {
+      "workflow_name": str,
+      "available_contexts": list[str],
+      "context_inheritance_model": dict,
+      "context_hierarchy_model": dict
+    }
+
+    Notes:
+    - available_contexts are derived from CommandContextModel.load(workflow_path)
+      so they reflect filesystem + inheritance.
+    - current context and purpose/description are intentionally omitted.
+    - Raw JSON for inheritance (from _commands/context_inheritance_model.json)
+      and hierarchy (from context_hierarchy_model.json) is returned verbatim when present.
+    """
+    if isinstance(chat_session_or_path, str):
+        workflow_path_str = chat_session_or_path
+    else:
+        workflow_path_str = chat_session_or_path.get_active_workflow().folderpath
+    workflow_name = os.path.basename(os.path.abspath(workflow_path_str))
+
+    available_contexts: list[str]
+    inheritance_json: dict[str, Any] = {}
+    hierarchy_json: dict[str, Any] = {}
+
+    try:
+        # Derive contexts via consolidated model
+        context_model = CommandContextModel.load(workflow_path_str)
+        # Do not normalize names beyond keeping what the model exposes
+        available_contexts = sorted([key for key in context_model._command_contexts.keys() if key != 'IntentDetection'])
+    except Exception:
+        available_contexts = ["/"]
+
+    # Load raw context inheritance model (if present)
+    try:
+        inheritance_path = Path(workflow_path_str) / "_commands" / "context_inheritance_model.json"
+        if inheritance_path.is_file():
+            inheritance_json = json.loads(inheritance_path.read_text())
+    except Exception:
+        inheritance_json = {}
+
+    # Load raw context hierarchy model (if present)
+    try:
+        hierarchy_path = Path(workflow_path_str) / "context_hierarchy_model.json"
+        if hierarchy_path.is_file():
+            hierarchy_json = json.loads(hierarchy_path.read_text())
+    except Exception:
+        hierarchy_json = {}
+
+    return {
+        "workflow_name": workflow_name,
+        "available_contexts": available_contexts,
+        "context_inheritance_model": inheritance_json,
+        "context_hierarchy_model": hierarchy_json,
+    }

{fastworkflow-2.15.13 → fastworkflow-2.17.0}/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