User: "Create a workflow that monitors my Gmail for invoices,
       extracts the data, and saves it to a Google Sheet"

SAM:  ✨ Creating workflow...
      ✨ Adding Gmail Trigger node...
      ✨ Adding Code node for extraction...
      ✨ Adding Google Sheets node...
      ✨ Connecting nodes...
      ✨ Done

      [Canvas updates in real-time as nodes appear]

# File: ai_sam_base/tools/canvas_tools.py

CANVAS_READ_TOOL = {
    "name": "canvas_read",
    "description": """Read and analyze the current workflow on the canvas.

    Use this tool to:
    - Get a list of all nodes in the workflow
    - Understand what each node does
    - See how nodes are connected
    - Find nodes by name or type
    - Analyze the workflow flow

    Returns structured information about the workflow that you can use
    to answer questions or plan modifications.""",

    "input_schema": {
        "type": "object",
        "properties": {
            "query_type": {
                "type": "string",
                "enum": ["full", "nodes", "connections", "node_by_id", "nodes_by_type", "flow_analysis"],
                "description": "Type of query to perform"
            },
            "node_id": {
                "type": "string",
                "description": "Node ID for node_by_id query"
            },
            "node_type": {
                "type": "string",
                "description": "Node type filter for nodes_by_type query (e.g., 'httpRequest', 'gmail')"
            }
        },
        "required": ["query_type"]
    }
}

# File: ai_sam_base/tools/canvas_tools.py

class CanvasReadTool:
    """Tool for reading and analyzing canvas workflows."""

    def __init__(self, env, canvas_id):
        self.env = env
        self.canvas_id = canvas_id
        self.canvas = env['canvas'].browse(canvas_id)

    def execute(self, query_type, node_id=None, node_type=None):
        """Execute a canvas read query."""

        if not self.canvas.exists():
            return {"error": f"Canvas {self.canvas_id} not found"}

        # Parse json_definition
        try:
            workflow = json.loads(self.canvas.json_definition or '{}')
        except json.JSONDecodeError:
            return {"error": "Invalid workflow JSON"}

        nodes = workflow.get('nodes', [])
        connections = workflow.get('connections', {})

        if query_type == "full":
            return self._get_full_analysis(nodes, connections)
        elif query_type == "nodes":
            return self._get_nodes_summary(nodes)
        elif query_type == "connections":
            return self._get_connections_summary(connections)
        elif query_type == "node_by_id":
            return self._get_node_by_id(nodes, node_id)
        elif query_type == "nodes_by_type":
            return self._get_nodes_by_type(nodes, node_type)
        elif query_type == "flow_analysis":
            return self._analyze_flow(nodes, connections)
        else:
            return {"error": f"Unknown query_type: {query_type}"}

    def _get_full_analysis(self, nodes, connections):
        """Get complete workflow analysis."""
        return {
            "workflow_name": self.canvas.name,
            "node_count": len(nodes),
            "connection_count": self._count_connections(connections),
            "nodes": self._get_nodes_summary(nodes)["nodes"],
            "connections": self._get_connections_summary(connections)["connections"],
            "triggers": [n for n in nodes if self._is_trigger(n)],
            "endpoints": self._find_endpoints(nodes, connections)
        }

    def _get_nodes_summary(self, nodes):
        """Get summary of all nodes."""
        return {
            "nodes": [
                {
                    "id": n.get("id"),
                    "name": n.get("name"),
                    "type": n.get("type", "").replace("n8n-nodes-base.", ""),
                    "position": n.get("position"),
                    "description": n.get("parameters", {}).get("description", "")[:100]
                }
                for n in nodes
            ]
        }

    def _get_connections_summary(self, connections):
        """Get summary of all connections."""
        result = []
        for source_id, targets in connections.items():
            if isinstance(targets, dict) and 'main' in targets:
                for output_idx, output_group in enumerate(targets['main']):
                    if isinstance(output_group, list):
                        for conn in output_group:
                            result.append({
                                "from": source_id,
                                "to": conn.get("node"),
                                "output_index": output_idx
                            })
        return {"connections": result}

    def _get_node_by_id(self, nodes, node_id):
        """Get detailed info for a specific node."""
        for node in nodes:
            if node.get("id") == node_id:
                return {"node": node}
        return {"error": f"Node {node_id} not found"}

    def _get_nodes_by_type(self, nodes, node_type):
        """Get all nodes of a specific type."""
        matching = [
            n for n in nodes
            if node_type.lower() in n.get("type", "").lower()
        ]
        return {"nodes": matching, "count": len(matching)}

    def _analyze_flow(self, nodes, connections):
        """Analyze the workflow execution flow."""
        # Build adjacency list
        graph = {}
        for source_id, targets in connections.items():
            if isinstance(targets, dict) and 'main' in targets:
                graph[source_id] = []
                for output_group in targets['main']:
                    if isinstance(output_group, list):
                        for conn in output_group:
                            graph[source_id].append(conn.get("node"))

        # Find triggers (nodes with no incoming connections)
        all_targets = set()
        for targets in graph.values():
            all_targets.update(targets)

        node_ids = {n.get("id") for n in nodes}
        triggers = node_ids - all_targets

        # Find endpoints (nodes with no outgoing connections)
        endpoints = node_ids - set(graph.keys())

        return {
            "triggers": list(triggers),
            "endpoints": list(endpoints),
            "graph": graph,
            "execution_order": self._topological_sort(graph, triggers)
        }

    def _topological_sort(self, graph, triggers):
        """Get execution order via topological sort."""
        visited = set()
        order = []

        def dfs(node_id):
            if node_id in visited:
                return
            visited.add(node_id)
            for next_node in graph.get(node_id, []):
                dfs(next_node)
            order.append(node_id)

        for trigger in triggers:
            dfs(trigger)

        return list(reversed(order))

    def _is_trigger(self, node):
        """Check if a node is a trigger."""
        node_type = node.get("type", "").lower()
        return "trigger" in node_type or "webhook" in node_type

    def _find_endpoints(self, nodes, connections):
        """Find workflow endpoint nodes."""
        all_targets = set()
        for targets in connections.values():
            if isinstance(targets, dict) and 'main' in targets:
                for output_group in targets['main']:
                    if isinstance(output_group, list):
                        for conn in output_group:
                            all_targets.add(conn.get("node"))

        node_ids = {n.get("id") for n in nodes}
        sources = set(connections.keys())
        endpoints = node_ids - sources

        return [n for n in nodes if n.get("id") in endpoints]

    def _count_connections(self, connections):
        """Count total connections."""
        count = 0
        for targets in connections.values():
            if isinstance(targets, dict) and 'main' in targets:
                for output_group in targets['main']:
                    if isinstance(output_group, list):
                        count += len(output_group)
        return count

# File: ai_sam_base/models/ai_brain.py (modification)

# Add to available tools when in canvas context
def _get_available_tools(self, context_data):
    """Get tools available for this context."""
    tools = []

    # ... existing tools ...

    # Canvas tools when in workflow chat mode
    if context_data.get('is_workflow_chat') or context_data.get('canvas_id'):
        from odoo.addons.ai_sam_base.tools.canvas_tools import CANVAS_READ_TOOL
        tools.append(CANVAS_READ_TOOL)

    return tools

// File: ai_sam/static/src/js/chat/chat_interaction.js (addition)

// === CANVAS OPERATIONS ===
'reading_workflow':   { emoji: GOLD_STAR, message: 'Reading workflow...', color: GOLD_COLOR, isGoldStar: true },
'analyzing_nodes':    { emoji: GOLD_STAR, message: 'Analyzing nodes...', color: GOLD_COLOR, isGoldStar: true },
'tracing_connections': { emoji: GOLD_STAR, message: 'Tracing connections...', color: GOLD_COLOR, isGoldStar: true },

CANVAS_EDIT_TOOL = {
    "name": "canvas_edit",
    "description": """Modify the workflow on the canvas.

    Use this tool to:
    - Add new nodes to the workflow
    - Remove existing nodes
    - Update node parameters
    - Add connections between nodes
    - Remove connections
    - Move nodes to new positions

    Changes are applied immediately and visible on the canvas.""",

    "input_schema": {
        "type": "object",
        "properties": {
            "action": {
                "type": "string",
                "enum": ["add_node", "remove_node", "update_node",
                         "add_connection", "remove_connection", "move_node"],
                "description": "Action to perform"
            },
            "node_type": {
                "type": "string",
                "description": "For add_node: N8N node type (e.g., 'n8n-nodes-base.httpRequest')"
            },
            "node_name": {
                "type": "string",
                "description": "Display name for the node"
            },
            "node_id": {
                "type": "string",
                "description": "Node ID for update/remove/move operations"
            },
            "position": {
                "type": "object",
                "properties": {
                    "x": {"type": "number"},
                    "y": {"type": "number"}
                },
                "description": "Canvas position [x, y] for add/move"
            },
            "parameters": {
                "type": "object",
                "description": "Node-specific parameters"
            },
            "connection": {
                "type": "object",
                "properties": {
                    "from_node": {"type": "string"},
                    "to_node": {"type": "string"},
                    "from_output": {"type": "integer", "default": 0},
                    "to_input": {"type": "integer", "default": 0}
                },
                "description": "For add/remove_connection"
            }
        },
        "required": ["action"]
    }
}

class CanvasEditTool:
    """Tool for editing canvas workflows."""

    def __init__(self, env, canvas_id):
        self.env = env
        self.canvas_id = canvas_id
        self.canvas = env['canvas'].browse(canvas_id)

    def execute(self, action, **kwargs):
        """Execute a canvas edit action."""

        if not self.canvas.exists():
            return {"error": f"Canvas {self.canvas_id} not found"}

        # Parse current workflow
        try:
            workflow = json.loads(self.canvas.json_definition or '{"nodes": [], "connections": {}}')
        except json.JSONDecodeError:
            workflow = {"nodes": [], "connections": {}}

        # Execute action
        if action == "add_node":
            result = self._add_node(workflow, **kwargs)
        elif action == "remove_node":
            result = self._remove_node(workflow, **kwargs)
        elif action == "update_node":
            result = self._update_node(workflow, **kwargs)
        elif action == "add_connection":
            result = self._add_connection(workflow, **kwargs)
        elif action == "remove_connection":
            result = self._remove_connection(workflow, **kwargs)
        elif action == "move_node":
            result = self._move_node(workflow, **kwargs)
        else:
            return {"error": f"Unknown action: {action}"}

        if result.get("error"):
            return result

        # Save updated workflow
        self.canvas.write({
            'json_definition': json.dumps(workflow)
        })

        # Push update to frontend (Phase 4)
        self._push_canvas_update(action, result)

        return result

    def _add_node(self, workflow, node_type, node_name, position=None, parameters=None, **kwargs):
        """Add a new node to the workflow."""

        # Generate unique node ID
        node_id = f"node-{uuid.uuid4().hex[:8]}"

        # Default position if not specified
        if not position:
            # Find a good position based on existing nodes
            position = self._calculate_next_position(workflow.get('nodes', []))

        # Create node structure (N8N compatible)
        new_node = {
            "id": node_id,
            "name": node_name,
            "type": node_type,
            "position": [position.get('x', 0), position.get('y', 0)],
            "typeVersion": 1,
            "parameters": parameters or {}
        }

        # Add to workflow
        if 'nodes' not in workflow:
            workflow['nodes'] = []
        workflow['nodes'].append(new_node)

        return {
            "success": True,
            "action": "add_node",
            "node": new_node
        }

    def _remove_node(self, workflow, node_id, **kwargs):
        """Remove a node and its connections."""

        nodes = workflow.get('nodes', [])
        original_count = len(nodes)

        # Remove node
        workflow['nodes'] = [n for n in nodes if n.get('id') != node_id]

        if len(workflow['nodes']) == original_count:
            return {"error": f"Node {node_id} not found"}

        # Remove connections involving this node
        connections = workflow.get('connections', {})

        # Remove outgoing connections
        if node_id in connections:
            del connections[node_id]

        # Remove incoming connections
        for source_id, targets in list(connections.items()):
            if isinstance(targets, dict) and 'main' in targets:
                for output_group in targets['main']:
                    if isinstance(output_group, list):
                        output_group[:] = [
                            conn for conn in output_group
                            if conn.get('node') != node_id
                        ]

        return {
            "success": True,
            "action": "remove_node",
            "node_id": node_id
        }

    def _update_node(self, workflow, node_id, parameters=None, node_name=None, **kwargs):
        """Update an existing node's parameters or name."""

        for node in workflow.get('nodes', []):
            if node.get('id') == node_id:
                if node_name:
                    node['name'] = node_name
                if parameters:
                    node['parameters'] = {**node.get('parameters', {}), **parameters}
                return {
                    "success": True,
                    "action": "update_node",
                    "node": node
                }

        return {"error": f"Node {node_id} not found"}

    def _add_connection(self, workflow, connection, **kwargs):
        """Add a connection between two nodes."""

        from_node = connection.get('from_node')
        to_node = connection.get('to_node')
        from_output = connection.get('from_output', 0)
        to_input = connection.get('to_input', 0)

        # Validate nodes exist
        node_ids = {n.get('id') for n in workflow.get('nodes', [])}
        if from_node not in node_ids:
            return {"error": f"Source node {from_node} not found"}
        if to_node not in node_ids:
            return {"error": f"Target node {to_node} not found"}

        # Initialize connections structure
        if 'connections' not in workflow:
            workflow['connections'] = {}

        if from_node not in workflow['connections']:
            workflow['connections'][from_node] = {'main': []}

        # Ensure enough output slots
        main = workflow['connections'][from_node]['main']
        while len(main) <= from_output:
            main.append([])

        # Add connection
        main[from_output].append({
            'node': to_node,
            'type': 'main',
            'index': to_input
        })

        return {
            "success": True,
            "action": "add_connection",
            "connection": {
                "from": from_node,
                "to": to_node,
                "from_output": from_output,
                "to_input": to_input
            }
        }

    def _remove_connection(self, workflow, connection, **kwargs):
        """Remove a connection between two nodes."""

        from_node = connection.get('from_node')
        to_node = connection.get('to_node')

        connections = workflow.get('connections', {})

        if from_node in connections:
            targets = connections[from_node]
            if isinstance(targets, dict) and 'main' in targets:
                for output_group in targets['main']:
                    if isinstance(output_group, list):
                        original_len = len(output_group)
                        output_group[:] = [
                            conn for conn in output_group
                            if conn.get('node') != to_node
                        ]
                        if len(output_group) < original_len:
                            return {
                                "success": True,
                                "action": "remove_connection",
                                "from": from_node,
                                "to": to_node
                            }

        return {"error": f"Connection from {from_node} to {to_node} not found"}

    def _move_node(self, workflow, node_id, position, **kwargs):
        """Move a node to a new position."""

        for node in workflow.get('nodes', []):
            if node.get('id') == node_id:
                node['position'] = [position.get('x', 0), position.get('y', 0)]
                return {
                    "success": True,
                    "action": "move_node",
                    "node_id": node_id,
                    "new_position": node['position']
                }

        return {"error": f"Node {node_id} not found"}

    def _calculate_next_position(self, nodes):
        """Calculate a good position for a new node."""
        if not nodes:
            return {'x': 250, 'y': 300}

        # Find rightmost node and add offset
        max_x = max(n.get('position', [0, 0])[0] for n in nodes)
        avg_y = sum(n.get('position', [0, 0])[1] for n in nodes) / len(nodes)

        return {'x': max_x + 250, 'y': avg_y}

    def _push_canvas_update(self, action, result):
        """Push update to frontend via WebSocket (Phase 4)."""
        # TODO: Implement in Phase 4
        pass

CANVAS_NODE_TYPES_TOOL = {
    "name": "canvas_node_types",
    "description": """Search for available node types to add to the workflow.

    Use this to find the correct node type when you need to add a node.
    For example, to find email-related nodes, search for "email" or "gmail".""",

    "input_schema": {
        "type": "object",
        "properties": {
            "search": {
                "type": "string",
                "description": "Search term (e.g., 'gmail', 'http', 'spreadsheet')"
            },
            "category": {
                "type": "string",
                "description": "Category filter (e.g., 'Communication', 'Data', 'AI')"
            },
            "limit": {
                "type": "integer",
                "default": 10,
                "description": "Maximum results to return"
            }
        },
        "required": ["search"]
    }
}

CANVAS_CREATE_TOOL = {
    "name": "canvas_create",
    "description": """Create a complete workflow from a description.

    Use this tool when the user describes a workflow they want to build.
    The tool will generate an appropriate workflow structure with nodes
    and connections based on the description.

    For complex workflows, this may create multiple nodes and connect them.""",

    "input_schema": {
        "type": "object",
        "properties": {
            "description": {
                "type": "string",
                "description": "Natural language description of the workflow"
            },
            "clear_existing": {
                "type": "boolean",
                "default": False,
                "description": "If true, clears existing nodes before creating"
            }
        },
        "required": ["description"]
    }
}

# File: ai_sam_base/api_communications/workflow_generator.py

class WorkflowGenerator:
    """
    Generates workflow structures from natural language descriptions.

    Uses pattern matching and templates to create appropriate node configurations.
    """

    # Common workflow patterns
    PATTERNS = {
        'api_to_storage': {
            'triggers': ['monitor', 'watch', 'when', 'on'],
            'actions': ['save', 'store', 'write', 'add'],
            'template': 'api_fetch_transform_store'
        },
        'email_processing': {
            'triggers': ['email', 'gmail', 'outlook', 'inbox'],
            'actions': ['process', 'extract', 'analyze'],
            'template': 'email_trigger_process'
        },
        'data_transformation': {
            'triggers': ['transform', 'convert', 'map'],
            'actions': ['format', 'clean', 'normalize'],
            'template': 'data_transform_chain'
        },
        'notification': {
            'triggers': ['notify', 'alert', 'send'],
            'actions': ['slack', 'email', 'sms'],
            'template': 'trigger_notify'
        }
    }

    # Node templates
    TEMPLATES = {
        'api_fetch_transform_store': {
            'nodes': [
                {'type': 'n8n-nodes-base.httpRequest', 'name': 'Fetch Data'},
                {'type': 'n8n-nodes-base.code', 'name': 'Transform Data'},
                {'type': 'n8n-nodes-base.googleSheets', 'name': 'Save to Sheets'}
            ],
            'connections': [[0, 1], [1, 2]]
        },
        'email_trigger_process': {
            'nodes': [
                {'type': 'n8n-nodes-base.gmailTrigger', 'name': 'Email Trigger'},
                {'type': 'n8n-nodes-base.code', 'name': 'Extract Data'},
                {'type': 'n8n-nodes-base.set', 'name': 'Format Output'}
            ],
            'connections': [[0, 1], [1, 2]]
        }
    }

    def generate(self, description, env, canvas_id):
        """Generate a workflow from a description."""

        # Detect pattern
        pattern = self._detect_pattern(description)

        if pattern:
            return self._apply_template(pattern, description, env, canvas_id)
        else:
            # Fall back to AI-generated structure
            return self._generate_with_ai(description, env, canvas_id)

    def _detect_pattern(self, description):
        """Detect which workflow pattern matches the description."""
        description_lower = description.lower()

        for pattern_name, pattern in self.PATTERNS.items():
            trigger_match = any(t in description_lower for t in pattern['triggers'])
            action_match = any(a in description_lower for a in pattern['actions'])
            if trigger_match and action_match:
                return pattern['template']

        return None

    def _apply_template(self, template_name, description, env, canvas_id):
        """Apply a workflow template."""
        template = self.TEMPLATES.get(template_name)
        if not template:
            return {"error": f"Template {template_name} not found"}

        edit_tool = CanvasEditTool(env, canvas_id)
        created_nodes = []

        # Create nodes
        for i, node_def in enumerate(template['nodes']):
            position = {'x': 250 + (i * 250), 'y': 300}
            result = edit_tool.execute(
                action='add_node',
                node_type=node_def['type'],
                node_name=node_def['name'],
                position=position
            )
            if result.get('success'):
                created_nodes.append(result['node'])
            else:
                return result

        # Create connections
        for from_idx, to_idx in template['connections']:
            edit_tool.execute(
                action='add_connection',
                connection={
                    'from_node': created_nodes[from_idx]['id'],
                    'to_node': created_nodes[to_idx]['id']
                }
            )

        return {
            "success": True,
            "action": "create_workflow",
            "nodes_created": len(created_nodes),
            "nodes": created_nodes,
            "template_used": template_name
        }

    def _generate_with_ai(self, description, env, canvas_id):
        """Generate workflow structure using AI reasoning."""
        # This would use the AI to reason about the workflow structure
        # For now, return a message suggesting manual creation
        return {
            "success": False,
            "message": "Complex workflow detected. I'll help you build it step by step.",
            "suggested_approach": "manual_guided"
        }

# File: ai_sam_workflows/channels/canvas_channel.py

from odoo.addons.bus.websocket import WebSocket

class CanvasChannel:
    """WebSocket channel for real-time canvas updates."""

    @staticmethod
    def get_channel_name(canvas_id):
        return f'canvas.{canvas_id}'

    @staticmethod
    def push_update(env, canvas_id, event_type, data):
        """Push an update to all clients viewing this canvas."""
        channel = CanvasChannel.get_channel_name(canvas_id)
        env['bus.bus']._sendone(channel, event_type, data)

// File: ai_sam_workflows/static/src/n8n/canvas/canvas_realtime.js

class CanvasRealtimeSync {
    constructor(canvasId, canvasManager, nodeManager) {
        this.canvasId = canvasId;
        this.canvasManager = canvasManager;
        this.nodeManager = nodeManager;
        this.channel = `canvas.${canvasId}`;

        this._subscribe();
    }

    _subscribe() {
        // Subscribe to Odoo bus
        this.busService = this.env.services.bus_service;
        this.busService.addChannel(this.channel);
        this.busService.addEventListener('notification', this._onNotification.bind(this));
    }

    _onNotification(event) {
        const { type, payload } = event.detail;

        switch (type) {
            case 'canvas.node_added':
                this._handleNodeAdded(payload);
                break;
            case 'canvas.node_removed':
                this._handleNodeRemoved(payload);
                break;
            case 'canvas.node_updated':
                this._handleNodeUpdated(payload);
                break;
            case 'canvas.connection_added':
                this._handleConnectionAdded(payload);
                break;
            case 'canvas.connection_removed':
                this._handleConnectionRemoved(payload);
                break;
        }
    }

    _handleNodeAdded(payload) {
        const { node } = payload;

        // Add node with animation
        this.nodeManager.createNodeFromData(node, {
            animate: true,
            highlight: true,
            source: 'sam'  // Visual indicator that SAM added this
        });
    }

    _handleNodeRemoved(payload) {
        const { node_id } = payload;

        // Remove with fade-out animation
        this.nodeManager.removeNode(node_id, {
            animate: true
        });
    }

    _handleNodeUpdated(payload) {
        const { node } = payload;

        // Update with flash animation
        this.nodeManager.updateNode(node.id, node, {
            animate: true,
            flash: true
        });
    }

    _handleConnectionAdded(payload) {
        const { connection } = payload;

        // Draw connection with animation
        this.canvasManager.connectionManager.addConnection(
            connection.from,
            connection.to,
            { animate: true, color: 'gold' }  // Gold to show SAM's work
        );
    }

    _handleConnectionRemoved(payload) {
        const { from, to } = payload;

        // Remove with fade animation
        this.canvasManager.connectionManager.removeConnection(from, to, {
            animate: true
        });
    }
}

// Additional activity states for canvas manipulation
'adding_node':        { emoji: GOLD_STAR, message: 'Adding {node_name}...', color: GOLD_COLOR, isGoldStar: true },
'removing_node':      { emoji: GOLD_STAR, message: 'Removing {node_name}...', color: GOLD_COLOR, isGoldStar: true },
'connecting_nodes':   { emoji: GOLD_STAR, message: 'Connecting nodes...', color: GOLD_COLOR, isGoldStar: true },
'updating_node':      { emoji: GOLD_STAR, message: 'Updating {node_name}...', color: GOLD_COLOR, isGoldStar: true },
'creating_workflow':  { emoji: GOLD_STAR, message: 'Creating workflow...', color: GOLD_COLOR, isGoldStar: true },

# File: ai_sam_workflows_base/models/canvas_history.py

class CanvasHistory(models.Model):
    _name = 'canvas.history'
    _description = 'Canvas Edit History'
    _order = 'create_date desc'

    canvas_id = fields.Many2one('canvas', required=True, ondelete='cascade')
    action_type = fields.Selection([
        ('add_node', 'Add Node'),
        ('remove_node', 'Remove Node'),
        ('update_node', 'Update Node'),
        ('add_connection', 'Add Connection'),
        ('remove_connection', 'Remove Connection'),
        ('move_node', 'Move Node'),
        ('bulk_edit', 'Bulk Edit'),
        ('create_workflow', 'Create Workflow'),
    ], required=True)

    # Snapshot of state before this action
    previous_state = fields.Text('Previous State (JSON)')

    # The action data (for replay)
    action_data = fields.Text('Action Data (JSON)')

    # Who performed the action
    performed_by = fields.Selection([
        ('user', 'User'),
        ('sam', 'SAM AI'),
    ], default='user')

    user_id = fields.Many2one('res.users', default=lambda self: self.env.user)

    # Undo state
    is_undone = fields.Boolean(default=False)

    def undo(self):
        """Undo this action by restoring previous state."""
        if self.is_undone:
            return {"error": "Already undone"}

        # Restore previous state
        self.canvas_id.write({
            'json_definition': self.previous_state
        })

        self.is_undone = True

        # Push update to canvas
        CanvasChannel.push_update(
            self.env,
            self.canvas_id.id,
            'canvas.state_restored',
            {'reason': 'undo', 'action_id': self.id}
        )

        return {"success": True, "action": "undo"}

    def redo(self):
        """Redo this action by re-applying it."""
        if not self.is_undone:
            return {"error": "Not undone, cannot redo"}

        # Re-apply the action
        action_data = json.loads(self.action_data)
        edit_tool = CanvasEditTool(self.env, self.canvas_id.id)
        result = edit_tool.execute(**action_data)

        if result.get('success'):
            self.is_undone = False

        return result

# Modification to CanvasEditTool.execute()

def execute(self, action, performed_by='sam', **kwargs):
    """Execute a canvas edit action with history recording."""

    # Capture previous state
    previous_state = self.canvas.json_definition

    # Execute the action (existing code)
    result = self._execute_action(action, **kwargs)

    if result.get('success'):
        # Record in history
        self.env['canvas.history'].create({
            'canvas_id': self.canvas_id,
            'action_type': action,
            'previous_state': previous_state,
            'action_data': json.dumps({'action': action, **kwargs}),
            'performed_by': performed_by
        })

    return result

CANVAS_UNDO_TOOL = {
    "name": "canvas_undo",
    "description": "Undo the last canvas edit action.",
    "input_schema": {
        "type": "object",
        "properties": {
            "steps": {
                "type": "integer",
                "default": 1,
                "description": "Number of steps to undo"
            }
        }
    }
}

CANVAS_REDO_TOOL = {
    "name": "canvas_redo",
    "description": "Redo the last undone canvas edit action.",
    "input_schema": {
        "type": "object",
        "properties": {
            "steps": {
                "type": "integer",
                "default": 1,
                "description": "Number of steps to redo"
            }
        }
    }
}

ai_sam_base/
├── tools/
│   ├── __init__.py
│   ├── canvas_tools.py          # Tool definitions & handlers
│   └── tool_registry.py         # Tool registration
│
├── services/
│   └── workflow_generator.py    # Workflow generation from descriptions

ai_sam_workflows_base/
├── models/
│   └── canvas_history.py        # Undo/redo history model

ai_sam_workflows/
├── channels/
│   └── canvas_channel.py        # WebSocket real-time sync
│
├── static/src/n8n/canvas/
│   └── canvas_realtime.js       # Frontend real-time listener