quantalogic 0.53.0__py3-none-any.whl → 0.56.0__py3-none-any.whl

quantalogic/flow/flow_manager_schema.py

@@ -4,13 +4,7 @@ from pydantic import BaseModel, Field, model_validator
 
 
 class FunctionDefinition(BaseModel):
-    """
-    Definition of a function used in the workflow.
-
-    This model supports both embedded functions (inline code) and external functions sourced
-    from Python modules, including PyPI packages, local files, or remote URLs.
-    """
-
+    """Definition of a function used in the workflow."""
     type: str = Field(
         ...,
         description="Type of function source. Must be 'embedded' for inline code or 'external' for module-based functions.",
@@ -55,16 +49,15 @@ class FunctionDefinition(BaseModel):
 
 class LLMConfig(BaseModel):
     """Configuration for LLM-based nodes."""
-
     model: str = Field(
         default="gpt-3.5-turbo", description="The LLM model to use (e.g., 'gpt-3.5-turbo', 'gemini/gemini-2.0-flash')."
     )
     system_prompt: Optional[str] = Field(None, description="System prompt defining the LLM's role or context.")
     prompt_template: str = Field(
-        default="{{ input }}", description="Jinja2 template for the user prompt (e.g., 'Summarize {{ text }}'). Ignored if prompt_file is set."
+        default="{{ input }}", description="Jinja2 template for the user prompt. Ignored if prompt_file is set."
     )
     prompt_file: Optional[str] = Field(
-        None, description="Path to an external Jinja2 template file (e.g., 'prompts/summary.j2'). Takes precedence over prompt_template if provided."
+        None, description="Path to an external Jinja2 template file. Takes precedence over prompt_template."
     )
     temperature: float = Field(
         default=0.7, ge=0.0, le=1.0, description="Controls randomness of LLM output (0.0 to 1.0)."
@@ -77,13 +70,10 @@ class LLMConfig(BaseModel):
     frequency_penalty: float = Field(
         default=0.0, ge=-2.0, le=2.0, description="Penalty for repeating words (-2.0 to 2.0)."
     )
-    stop: Optional[List[str]] = Field(None, description="List of stop sequences for LLM generation (e.g., ['\\n']).")
+    stop: Optional[List[str]] = Field(None, description="List of stop sequences for LLM generation.")
     response_model: Optional[str] = Field(
         None,
-        description=(
-            "Path to a Pydantic model for structured output (e.g., 'my_module:OrderDetails'). "
-            "If specified, uses structured_llm_node; otherwise, uses llm_node."
-        ),
+        description="Path to a Pydantic model for structured output (e.g., 'my_module:OrderDetails')."
     )
     api_key: Optional[str] = Field(None, description="Custom API key for the LLM provider, if required.")
 
@@ -97,13 +87,30 @@ class LLMConfig(BaseModel):
         return data
 
 
-class NodeDefinition(BaseModel):
-    """
-    Definition of a workflow node.
+class TemplateConfig(BaseModel):
+    """Configuration for template-based nodes."""
+    template: str = Field(
+        default="", description="Jinja2 template string to render. Ignored if template_file is set."
+    )
+    template_file: Optional[str] = Field(
+        None, description="Path to an external Jinja2 template file. Takes precedence over template."
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_template_source(cls, data: Any) -> Any:
+        """Ensure template_file and template are used appropriately."""
+        template_file = data.get("template_file")
+        template = data.get("template")
+        if not template and not template_file:
+            raise ValueError("Either 'template' or 'template_file' must be provided")
+        if template_file and not isinstance(template_file, str):
+            raise ValueError("template_file must be a string path to a Jinja2 template file")
+        return data
 
-    A node must specify exactly one of 'function', 'sub_workflow', or 'llm_config'.
-    """
 
+class NodeDefinition(BaseModel):
+    """Definition of a workflow node with template_node and inputs_mapping support."""
     function: Optional[str] = Field(
         None, description="Name of the function to execute (references a FunctionDefinition)."
     )
@@ -111,12 +118,14 @@ class NodeDefinition(BaseModel):
         None, description="Nested workflow definition for sub-workflow nodes."
     )
     llm_config: Optional[LLMConfig] = Field(None, description="Configuration for LLM-based nodes.")
+    template_config: Optional[TemplateConfig] = Field(None, description="Configuration for template-based nodes.")
+    inputs_mapping: Optional[Dict[str, str]] = Field(
+        None,
+        description="Mapping of node inputs to context keys or stringified lambda expressions (e.g., 'lambda ctx: value')."
+    )
     output: Optional[str] = Field(
         None,
-        description=(
-            "Context key to store the node's result. Defaults to '<node_name>_result' "
-            "for function or LLM nodes if not specified."
-        ),
+        description="Context key to store the node's result. Defaults to '<node_name>_result' if applicable."
     )
     retries: int = Field(default=3, ge=0, description="Number of retry attempts on failure.")
     delay: float = Field(default=1.0, ge=0.0, description="Delay in seconds between retries.")
@@ -127,62 +136,72 @@ class NodeDefinition(BaseModel):
 
     @model_validator(mode="before")
     @classmethod
-    def check_function_or_sub_workflow_or_llm(cls, data: Any) -> Any:
-        """Ensure a node has exactly one of 'function', 'sub_workflow', or 'llm_config'."""
+    def check_function_or_sub_workflow_or_llm_or_template(cls, data: Any) -> Any:
+        """Ensure a node has exactly one of 'function', 'sub_workflow', 'llm_config', or 'template_config'."""
         func = data.get("function")
         sub_wf = data.get("sub_workflow")
         llm = data.get("llm_config")
-        if sum(x is not None for x in (func, sub_wf, llm)) != 1:
-            raise ValueError("Node must have exactly one of 'function', 'sub_workflow', or 'llm_config'")
+        template = data.get("template_config")
+        if sum(x is not None for x in (func, sub_wf, llm, template)) != 1:
+            raise ValueError("Node must have exactly one of 'function', 'sub_workflow', 'llm_config', or 'template_config'")
         return data
 
 
+class BranchCondition(BaseModel):
+    """Definition of a branch condition for a transition."""
+    to_node: str = Field(
+        ..., description="Target node name for this branch."
+    )
+    condition: Optional[str] = Field(
+        None, description="Python expression using 'ctx' for conditional branching."
+    )
+
+
 class TransitionDefinition(BaseModel):
     """Definition of a transition between nodes."""
-
     from_node: str = Field(
         ...,
         description="Source node name for the transition.",
     )
-    to_node: Union[str, List[str]] = Field(
-        ..., description="Target node(s). A string for sequential, a list for parallel execution."
+    to_node: Union[str, List[Union[str, BranchCondition]]] = Field(
+        ...,
+        description=(
+            "Target node(s). Can be: a string, list of strings (parallel), or list of BranchCondition (branching)."
+        ),
     )
     condition: Optional[str] = Field(
-        None, description="Python expression using 'ctx' for conditional transitions (e.g., 'ctx.get(\"in_stock\")')."
+        None,
+        description="Python expression using 'ctx' for simple transitions."
     )
 
 
 class WorkflowStructure(BaseModel):
     """Structure defining the workflow's execution flow."""
-
     start: Optional[str] = Field(None, description="Name of the starting node.")
     transitions: List[TransitionDefinition] = Field(
         default_factory=list, description="List of transitions between nodes."
     )
+    convergence_nodes: List[str] = Field(
+        default_factory=list, description="List of nodes where branches converge."
+    )
 
 
 class WorkflowDefinition(BaseModel):
     """Top-level definition of the workflow."""
-
     functions: Dict[str, FunctionDefinition] = Field(
-        default_factory=dict, description="Dictionary of function definitions used in the workflow."
+        default_factory=dict, description="Dictionary of function definitions."
     )
     nodes: Dict[str, NodeDefinition] = Field(default_factory=dict, description="Dictionary of node definitions.")
     workflow: WorkflowStructure = Field(
-        default_factory=lambda: WorkflowStructure(start=None), description="Main workflow structure with start node and transitions."
+        default_factory=lambda: WorkflowStructure(start=None), description="Main workflow structure."
     )
     observers: List[str] = Field(
-        default_factory=list, description="List of observer function names to monitor workflow execution."
+        default_factory=list, description="List of observer function names."
     )
     dependencies: List[str] = Field(
         default_factory=list,
-        description=(
-            "List of Python module dependencies required by the workflow. "
-            "Examples: PyPI packages ('requests>=2.28.0'), local paths ('/path/to/module.py'), "
-            "or remote URLs ('https://example.com/module.py'). Processed during workflow instantiation."
-        ),
+        description="List of Python module dependencies."
     )
 
 
-# Resolve forward reference for sub_workflow in NodeDefinition
 NodeDefinition.model_rebuild()

quantalogic/flow/flow_mermaid.py

@@ -1,8 +1,8 @@
 import re
-from typing import Dict, List, Optional, Set, Tuple
+from typing import Dict, List, Optional, Set, Tuple, Union
 
 from quantalogic.flow.flow_manager import WorkflowManager
-from quantalogic.flow.flow_manager_schema import NodeDefinition, WorkflowDefinition
+from quantalogic.flow.flow_manager_schema import BranchCondition, NodeDefinition, WorkflowDefinition
 
 
 def get_node_label_and_type(node_name: str, node_def: Optional[NodeDefinition], has_conditions: bool) -> Tuple[str, str, str]:
@@ -12,29 +12,48 @@ def get_node_label_and_type(node_name: str, node_def: Optional[NodeDefinition],
     Args:
         node_name: The name of the node.
         node_def: The NodeDefinition object from the workflow, or None if undefined.
-        has_conditions: True if the node has outgoing transitions with conditions.
+        has_conditions: True if the node has outgoing transitions with conditions (branching).
 
     Returns:
         A tuple of (display label, type key for styling, shape identifier).
     """
-    # No truncation unless necessary, escape quotes for safety
+    # Escape quotes for Mermaid compatibility
     escaped_name = node_name.replace('"', '\\"')
-
-    # Use diamond shape for nodes with conditional transitions, rectangle otherwise
     shape = "diamond" if has_conditions else "rect"
 
     if not node_def:
         return f"{escaped_name} (unknown)", "unknown", shape
-    
+
+    # Base label starts with node name and type
     if node_def.function:
-        return f"{escaped_name} (function)", "function", shape
+        label = f"{escaped_name} (function)"
+        node_type = "function"
     elif node_def.llm_config:
         if node_def.llm_config.response_model:
-            return f"{escaped_name} (structured LLM)", "structured_llm", shape
-        return f"{escaped_name} (LLM)", "llm", shape
+            label = f"{escaped_name} (structured LLM)"
+            node_type = "structured_llm"
+        else:
+            label = f"{escaped_name} (LLM)"
+            node_type = "llm"
+    elif node_def.template_config:
+        label = f"{escaped_name} (template)"
+        node_type = "template"
     elif node_def.sub_workflow:
-        return f"{escaped_name} (Sub-Workflow)", "sub_workflow", shape
-    return f"{escaped_name} (unknown)", "unknown", shape
+        label = f"{escaped_name} (Sub-Workflow)"
+        node_type = "sub_workflow"
+    else:
+        label = f"{escaped_name} (unknown)"
+        node_type = "unknown"
+
+    # Append inputs_mapping if present
+    if node_def and node_def.inputs_mapping:
+        mapping_str = ", ".join(f"{k}={v}" for k, v in node_def.inputs_mapping.items())
+        # Truncate if too long for readability (e.g., > 30 chars)
+        if len(mapping_str) > 30:
+            mapping_str = mapping_str[:27] + "..."
+        label += f"\\nInputs: {mapping_str}"
+
+    return label, node_type, shape
 
 
 def generate_mermaid_diagram(
@@ -51,7 +70,7 @@ def generate_mermaid_diagram(
         workflow_def: The workflow definition to visualize.
         include_subgraphs: If True, nests sub-workflows in Mermaid subgraphs (flowchart only).
         title: Optional title for the diagram.
-        include_legend: If True, adds a comment-based legend explaining node types.
+        include_legend: If True, adds a comment-based legend explaining node types and shapes.
         diagram_type: Type of diagram to generate: "flowchart" (default) or "stateDiagram".
 
     Returns:
@@ -68,6 +87,7 @@ def generate_mermaid_diagram(
         "function": "fill:#90CAF9,stroke:#42A5F5,stroke-width:2px",           # Pastel Blue
         "structured_llm": "fill:#A5D6A7,stroke:#66BB6A,stroke-width:2px",    # Pastel Green
         "llm": "fill:#CE93D8,stroke:#AB47BC,stroke-width:2px",               # Pastel Purple
+        "template": "fill:#FCE4EC,stroke:#F06292,stroke-width:2px",          # Pastel Pink (new for template)
         "sub_workflow": "fill:#FFCCBC,stroke:#FF7043,stroke-width:2px",      # Pastel Orange
         "unknown": "fill:#CFD8DC,stroke:#B0BEC5,stroke-width:2px"            # Pastel Grey
     }
@@ -75,7 +95,7 @@ def generate_mermaid_diagram(
     # Shape mappings for flowchart syntax
     shape_syntax: Dict[str, Tuple[str, str]] = {
         "rect": ("[", "]"),      # Rectangle for standard nodes
-        "diamond": ("{{", "}}")   # Diamond for decision points
+        "diamond": ("{{", "}}")   # Diamond for decision points (branching)
     }
 
     # Validate node names for Mermaid compatibility (alphanumeric, underscore, hyphen)
@@ -94,17 +114,26 @@ def generate_mermaid_diagram(
                 raise ValueError(f"Invalid node name '{trans.to_node}' for Mermaid")
             all_nodes.add(trans.to_node)
         else:
-            for to_node in trans.to_node:
-                if re.search(invalid_chars, to_node):
-                    raise ValueError(f"Invalid node name '{to_node}' for Mermaid")
-                all_nodes.add(to_node)
-
-    # Determine which nodes have conditional transitions
+            for tn in trans.to_node:
+                target = tn if isinstance(tn, str) else tn.to_node
+                if re.search(invalid_chars, target):
+                    raise ValueError(f"Invalid node name '{target}' for Mermaid")
+                all_nodes.add(target)
+    for conv_node in workflow_def.workflow.convergence_nodes:
+        if re.search(invalid_chars, conv_node):
+            raise ValueError(f"Invalid node name '{conv_node}' for Mermaid")
+        all_nodes.add(conv_node)
+
+    # Determine nodes with conditional transitions (branching)
     conditional_nodes: Set[str] = set()
     for trans in workflow_def.workflow.transitions:
-        if trans.condition and isinstance(trans.to_node, str):
+        if (trans.condition and isinstance(trans.to_node, str)) or \
+           (isinstance(trans.to_node, list) and any(isinstance(tn, BranchCondition) and tn.condition for tn in trans.to_node)):
             conditional_nodes.add(trans.from_node)
 
+    # Identify convergence nodes
+    convergence_nodes: Set[str] = set(workflow_def.workflow.convergence_nodes)
+
     # Shared node definitions and types
     node_types: Dict[str, str] = {}
     node_shapes: Dict[str, str] = {}  # Only used for flowchart
@@ -119,13 +148,14 @@ def generate_mermaid_diagram(
     if title:
         mermaid_code += f"    %% Diagram: {title}\n"
 
-    # Optional legend for UX
+    # Optional legend for UX, updated to include template nodes
     if include_legend:
         mermaid_code += "    %% Legend:\n"
         if diagram_type == "flowchart":
-            mermaid_code += "    %% - Rectangle: Process Step\n"
-            mermaid_code += "    %% - Diamond: Decision Point\n"
-        mermaid_code += "    %% - Colors: Blue (Function), Green (Structured LLM), Purple (LLM), Orange (Sub-Workflow), Grey (Unknown)\n"
+            mermaid_code += "    %% - Rectangle: Process Step or Convergence Point\n"
+            mermaid_code += "    %% - Diamond: Decision Point (Branching)\n"
+        mermaid_code += "    %% - Colors: Blue (Function), Green (Structured LLM), Purple (LLM), Pink (Template), Orange (Sub-Workflow), Grey (Unknown)\n"
+        mermaid_code += "    %% - Dashed Border: Convergence Node\n"
 
     if diagram_type == "flowchart":
         # Flowchart-specific: Generate node definitions with shapes
@@ -140,10 +170,10 @@ def generate_mermaid_diagram(
             node_shapes[node] = shape
 
         # Add node definitions
-        for node_def_str in node_defs:
+        for node_def_str in sorted(node_defs):  # Sort for consistent output
             mermaid_code += f"    {node_def_str}\n"
 
-        # Generate arrows for transitions (all solid lines)
+        # Generate arrows for transitions
         for trans in workflow_def.workflow.transitions:
             from_node = trans.from_node
             if isinstance(trans.to_node, str):
@@ -155,15 +185,29 @@ def generate_mermaid_diagram(
                 else:
                     mermaid_code += f'    {from_node} --> {to_node}\n'
             else:
-                for to_node in trans.to_node:
-                    mermaid_code += f'    {from_node} --> {to_node}\n'
+                for tn in trans.to_node:
+                    if isinstance(tn, str):
+                        # Parallel transition (no condition)
+                        mermaid_code += f'    {from_node} --> {tn}\n'
+                    else:  # BranchCondition
+                        to_node = tn.to_node
+                        condition = tn.condition
+                        if condition:
+                            cond = condition.replace('"', '\\"')[:30] + ("..." if len(condition) > 30 else "")
+                            mermaid_code += f'    {from_node} -->|"{cond}"| {to_node}\n'
+                        else:
+                            mermaid_code += f'    {from_node} --> {to_node}\n'
 
         # Add styles for node types
         for node, node_type in node_types.items():
             if node_type in node_styles:
-                mermaid_code += f"    style {node} {node_styles[node_type]}\n"
+                style = node_styles[node_type]
+                # Add dashed stroke for convergence nodes
+                if node in convergence_nodes:
+                    style += ",stroke-dasharray:5 5"
+                mermaid_code += f"    style {node} {style}\n"
 
-        # Highlight the start node
+        # Highlight the start node with a thicker border
         if workflow_def.workflow.start and workflow_def.workflow.start in node_types:
             mermaid_code += f"    style {workflow_def.workflow.start} stroke-width:4px\n"
 
@@ -178,8 +222,10 @@ def generate_mermaid_diagram(
                         if isinstance(trans.to_node, str):
                             sub_nodes.add(trans.to_node)
                         else:
-                            sub_nodes.update(trans.to_node)
-                    for sub_node in sub_nodes:
+                            for tn in trans.to_node:
+                                target = tn if isinstance(tn, str) else tn.to_node
+                                sub_nodes.add(target)
+                    for sub_node in sorted(sub_nodes):  # Sort for consistency
                         mermaid_code += f"        {sub_node}[[{sub_node}]]\n"
                     mermaid_code += "    end\n"
 
@@ -189,6 +235,9 @@ def generate_mermaid_diagram(
             node_def_state: Optional[NodeDefinition] = workflow_def.nodes.get(node)
             has_conditions = node in conditional_nodes
             label, node_type, _ = get_node_label_and_type(node, node_def_state, has_conditions)  # Shape unused
+            # Append (Convergence) to label for convergence nodes
+            if node in convergence_nodes:
+                label += " (Convergence)"
             mermaid_code += f"    state \"{label}\" as {node}\n"
             node_types[node] = node_type
 
@@ -208,75 +257,109 @@ def generate_mermaid_diagram(
                 else:
                     mermaid_code += f"    {from_node} --> {to_node}\n"
             else:
-                # Parallel transitions approximated with a note
-                for to_node in trans.to_node:
-                    mermaid_code += f"    {from_node} --> {to_node} : parallel\n"
+                for tn in trans.to_node:
+                    if isinstance(tn, str):
+                        # Parallel transition approximated with a note
+                        mermaid_code += f"    {from_node} --> {tn} : parallel\n"
+                    else:  # BranchCondition
+                        to_node = tn.to_node
+                        condition = tn.condition
+                        if condition:
+                            cond = condition.replace('"', '\\"')[:30] + ("..." if len(condition) > 30 else "")
+                            mermaid_code += f"    {from_node} --> {to_node} : {cond}\n"
+                        else:
+                            mermaid_code += f"    {from_node} --> {to_node}\n"
 
         # Add styles for node types
         for node, node_type in node_types.items():
             if node_type in node_styles:
-                mermaid_code += f"    style {node} {node_styles[node_type]}\n"
+                style = node_styles[node_type]
+                # Add dashed stroke for convergence nodes
+                if node in convergence_nodes:
+                    style += ",stroke-dasharray:5 5"
+                mermaid_code += f"    style {node} {style}\n"
 
     mermaid_code += "```\n"
     return mermaid_code
 
 
 def main() -> None:
-    """Create a complex workflow and print its improved Mermaid diagram representation."""
+    """Create a complex workflow with branch, converge, template node, and input mapping, and print its Mermaid diagram."""
     manager = WorkflowManager()
 
     # Add functions
     manager.add_function(
-        name="analyze_sentiment",
+        name="say_hello",
         type_="embedded",
-        code="async def analyze_sentiment(summary: str) -> str:\n    return 'positive' if 'good' in summary.lower() else 'negative'",
+        code="def say_hello():\n    return 'Hello, World!'"
     )
     manager.add_function(
-        name="extract_keywords",
+        name="check_condition",
         type_="embedded",
-        code="async def extract_keywords(summary: str) -> str:\n    return 'key1, key2'",
+        code="def check_condition(text: str):\n    return 'yes' if 'Hello' in text else 'no'"
     )
     manager.add_function(
-        name="publish_content",
+        name="say_goodbye",
         type_="embedded",
-        code="async def publish_content(summary: str, sentiment: str, keywords: str) -> str:\n    return 'Published'",
+        code="def say_goodbye():\n    return 'Goodbye, World!'"
     )
     manager.add_function(
-        name="revise_content",
+        name="finalize",
         type_="embedded",
-        code="async def revise_content(summary: str) -> str:\n    return 'Revised summary'",
+        code="def finalize(text: str):\n    return 'Done'"
     )
 
+    # Add nodes
+    manager.add_node(name="start", function="say_hello", output="text")
+    manager.add_node(name="check", function="check_condition", output="result",
+                     inputs_mapping={"text": "text"})
+    manager.add_node(name="goodbye", function="say_goodbye", output="farewell")
+    manager.add_node(name="finalize", function="finalize", output="status",
+                     inputs_mapping={"text": "lambda ctx: ctx['farewell'] if ctx['result'] == 'no' else ctx['ai_result']"})
+
     # Add LLM node
-    llm_config = {
-        "model": "grok/xai",
-        "system_prompt": "You are a concise summarizer.",
-        "prompt_template": "Summarize the following text: {{ input_text }}",
-        "temperature": "0.5",
-        "max_tokens": "150",
-    }
-    manager.add_node(name="summarize_text", llm_config=llm_config, output="summary")
+    manager.add_node(
+        name="ai_node",
+        llm_config={
+            "model": "gpt-3.5-turbo",
+            "prompt_template": "{{text}}",
+            "temperature": 0.7
+        },
+        output="ai_result"
+    )
 
-    # Add function nodes
-    manager.add_node(name="sentiment_analysis", function="analyze_sentiment", output="sentiment")
-    manager.add_node(name="keyword_extraction", function="extract_keywords", output="keywords")
-    manager.add_node(name="publish", function="publish_content", output="status")
-    manager.add_node(name="revise", function="revise_content", output="revised_summary")
+    # Add template node
+    manager.add_node(
+        name="template_node",
+        template_config={
+            "template": "Response: {{text}} - {{result}}"
+        },
+        output="template_output",
+        inputs_mapping={"text": "text", "result": "result"}
+    )
 
-    # Define workflow structure
-    manager.set_start_node("summarize_text")
-    manager.add_transition(from_node="summarize_text", to_node=["sentiment_analysis", "keyword_extraction"])
-    manager.add_transition(from_node="sentiment_analysis", to_node="publish", condition="ctx['sentiment'] == 'positive'")
-    manager.add_transition(from_node="sentiment_analysis", to_node="revise", condition="ctx['sentiment'] == 'negative'")
-    manager.add_transition(from_node="keyword_extraction", to_node="publish")
+    # Define workflow structure with branch and converge
+    manager.set_start_node("start")
+    manager.add_transition(from_node="start", to_node="check")
+    manager.add_transition(
+        from_node="check",
+        to_node=[
+            BranchCondition(to_node="ai_node", condition="ctx['result'] == 'yes'"),
+            BranchCondition(to_node="goodbye", condition="ctx['result'] == 'no'")
+        ]
+    )
+    manager.add_transition(from_node="ai_node", to_node="finalize")
+    manager.add_transition(from_node="goodbye", to_node="finalize")
+    manager.add_transition(from_node="finalize", to_node="template_node")
+    manager.add_convergence_node("finalize")
 
     # Generate and print both diagrams
     workflow_def = manager.workflow
     print("Flowchart (default):")
-    print(generate_mermaid_diagram(workflow_def, include_subgraphs=False, title="Content Processing Workflow"))
+    print(generate_mermaid_diagram(workflow_def, include_subgraphs=False, title="Sample Workflow with Template and Mapping"))
     print("\nState Diagram:")
-    print(generate_mermaid_diagram(workflow_def, diagram_type="stateDiagram", title="Content Processing Workflow"))
-    
+    print(generate_mermaid_diagram(workflow_def, diagram_type="stateDiagram", title="Sample Workflow with Template and Mapping"))
+
 
 if __name__ == "__main__":
     main()