implemented graph.py, agents, guard; reduced image and video node to viewer node; renamed system prompts

agents.py

@@ -33,7 +33,7 @@ class Summarizer(IAgent):
     Generates concise summaries of conversations or passages.
     """
     def __init__(self):
-        super().__init__("04_summarizer.txt", PRIMARY_AGENT_PRESET)
+        super().__init__("03_summarizer.txt", PRIMARY_AGENT_PRESET)
 
 
 class Solver(IAgent):
@@ -41,7 +41,7 @@ class Solver(IAgent):
     Central problem-solving node that coordinates with specialized experts based on task requirements
     """
     def __init__(self):
-        super().__init__("03_solver.txt", PRIMARY_AGENT_PRESET)
+        super().__init__("04_solver.txt", PRIMARY_AGENT_PRESET)
 
 
 class Researcher(IAgent):
@@ -77,28 +77,20 @@ class Reasoner(IAgent):
             encryption_toolbox.caesar_cipher_brute_force,
             encryption_toolbox.reverse_string
             ]
-        super().__init__("08_reasoner.txt", PRIMARY_AGENT_PRESET, tools)
+        super().__init__("06_reasoner.txt", PRIMARY_AGENT_PRESET, tools)
 
 
-class OutputGuard(IAgent):
-    """
-    Performs logical reasoning, inference, and step-by-step problem-solving
-    """
-    def __init__(self):
-        super().__init__("11_output_guard.txt", SECONDARY_AGENT_PRESET)
-
-
-class ImageHandler(IAgent):
+class Viewer(IAgent):
     """
     Processes, analyzes, and generates information related to images
     """
     def __init__(self):
-        super().__init__("09_image_handler.txt", VISION_AGENT_PRESET)
+        super().__init__("07_viewer.txt", VISION_AGENT_PRESET)
 
 
-class VideoHandler(IAgent):
+class OutputGuard(IAgent):
     """
-    Processes, analyzes, and generates information related to videos
+    Performs logical reasoning, inference, and step-by-step problem-solving
     """
     def __init__(self):
-        super().__init__("10_video_handler.txt", VISION_AGENT_PRESET)
+        super().__init__("08_output_guard.txt", SECONDARY_AGENT_PRESET)

alfred.py

@@ -6,7 +6,10 @@ from graph_builder import GraphBuilder
 
 
 # Maximum number of interactions between Assistant and Manager
-MAX_INTERACTIONS = 5
+MAX_INTERACTIONS = 6
+# Verification happening every few messages to check whether the manager agent
+#   is making progress or it got stuck (in a repetitive loop or similar pitfalls)
+AUDIT_INTERVAL = 3
 # Maximum depth of recursion for Manager
 MAX_DEPTH = 2
 # For both Assistant and Manager:

args.py

@@ -14,10 +14,10 @@ class Args:
     LOGGER = Logger.set_logger()
     primary_llm_interface=LLMInterface.OPENAI
     # secondary_llm_interface=LLMInterface.HUGGINGFACE
-    vlm_interface=LLMInterface.HUGGINGFACE
+    vlm_interface=LLMInterface.OPENAI
     primary_model="qwen2.5-qwq-35b-eureka-cubed-abliterated-uncensored"
     secondary_model="qwen2.5-7b-instruct-1m"
-    vision_model="gemma-3-27b-it"
+    vision_model="qwen/qwen2.5-vl-7b"
     api_base="http://127.0.0.1:1234/v1"  # LM Studio local endpoint
     api_key=None
     token = ""  # Not needed when using OpenAILike API

design.puml

@@ -8,36 +8,32 @@ node START TERMINAL_NODE_COLOR[
   START
 ]
 
-node manager NOT_IMPLEMENTED_NODE_COLOR[
+node manager IMPLEMENTED_NODE_COLOR[
   manager
 ]
 
-node final_answer NOT_IMPLEMENTED_NODE_COLOR[
+node final_answer IMPLEMENTED_NODE_COLOR[
   final_answer
 ]
 
-node auditor NOT_IMPLEMENTED_NODE_COLOR[
+node auditor IMPLEMENTED_NODE_COLOR[
   auditor
 ]
 
-node solver NOT_IMPLEMENTED_NODE_COLOR[
+node solver IMPLEMENTED_NODE_COLOR[
   solver
 ]
 
-node researcher NOT_IMPLEMENTED_NODE_COLOR[
+node researcher IMPLEMENTED_NODE_COLOR[
   researcher
 ]
 
-node reasoner NOT_IMPLEMENTED_NODE_COLOR[
+node reasoner IMPLEMENTED_NODE_COLOR[
   reasoner
 ]
 
-node image_handler NOT_IMPLEMENTED_NODE_COLOR[
-  image_handler
-]
-
-node video_handler NOT_IMPLEMENTED_NODE_COLOR[
-  video_handler
+node viewer NOT_IMPLEMENTED_NODE_COLOR[
+  viewer
 ]
 
 node END TERMINAL_NODE_COLOR[
@@ -53,11 +49,9 @@ auditor --> manager
 solver --> manager
 solver --> researcher
 solver --> reasoner
-solver --> image_handler
-solver --> video_handler
+solver --> viewer
 researcher --> solver
 reasoner --> solver
-image_handler --> solver
-video_handler --> solver
+viewer --> solver
 
 @enduml

design.yaml

@@ -8,39 +8,34 @@ nodes:
 - name: manager
   connections: [solver, auditor, final_answer]
   description: Orchestrates the workflow by delegating tasks to specialized nodes and integrating their outputs
-  status: NOT_IMPLEMENTED
+  status: IMPLEMENTED
 
 - name: final_answer
   connections: [END]
   description: Formats and delivers the final response to the user
-  status: NOT_IMPLEMENTED
+  status: IMPLEMENTED
 
 - name: auditor
   connections: [manager]
   description: Reviews manager's outputs for accuracy, safety, and quality
-  status: NOT_IMPLEMENTED
+  status: IMPLEMENTED
 
 - name: solver
-  connections: [manager, researcher, reasoner, image_handler, video_handler]
+  connections: [manager, researcher, reasoner, viewer]
   description: Central problem-solving node that coordinates with specialized experts based on task requirements
-  status: NOT_IMPLEMENTED
+  status: IMPLEMENTED
 
 - name: researcher
   connections: [solver]
   description: Retrieves and synthesizes information from various sources to answer knowledge-based questions
-  status: NOT_IMPLEMENTED
+  status: IMPLEMENTED
 
 - name: reasoner
   connections: [solver]
   description: Performs logical reasoning, inference, and step-by-step problem-solving
-  status: NOT_IMPLEMENTED
+  status: IMPLEMENTED
 
-- name: image_handler
+- name: viewer
   connections: [solver]
-  description: Processes, analyzes, and generates information related to images
-  status: NOT_IMPLEMENTED
-
-- name: video_handler
-  connections: [solver]
-  description: Processes, analyzes, and generates information related to videos
+  description: Processes, analyzes, and generates vision related information
   status: NOT_IMPLEMENTED

graph.py

@@ -8,17 +8,77 @@ import logging
 from pathlib import Path
 
 from args import Args
+from agents import *
+from itf_agent import IAgent
 
 
 class State(TypedDict):
     """State class for the agent graph."""
     initial_query: str
     # messages: List[Dict[str, Any]]
-    messages: Annotated[list[AnyMessage], add_messages]
-    nr_interactions: int
+    # messages: Annotated[list[BaseMessage], add_messages]
+    messages: List[BaseMessage]  # Manager's context
+    task_progress: List[BaseMessage]  # Solver's context
+    audit_interval: int
+    manager_queries: int
+    solver_queries: int
+    max_interactions: int
+    max_solving_effort: int
     final_response: Optional[str]
 
 
+class Agents:
+    manager = Manager()
+    auditor = Auditor()
+    summarizer = Summarizer()
+    solver = Solver()
+    researcher = Researcher()
+    reasoner = Reasoner()
+    guardian = OutputGuard()
+    viewer = Viewer()
+
+    @classmethod
+    def guard_output(cls, agent: IAgent, messages: List[BaseMessage]) -> BaseMessage:
+        response = agent.query(messages)
+        guarded_response = cls.guardian.query([response])
+        return guarded_response
+
+
+class _Helper:
+    """
+    Collection of helper methods.
+    """
+    @staticmethod
+    def _is_divisible(first: int, second: int) -> bool:
+        """
+        Determines if the first number is divisible by the second number.
+        
+        Args:
+            first: The dividend (number to be divided)
+            second: The divisor (number to divide by)
+            
+        Returns:
+            bool: True if first is divisible by second without remainder, False otherwise
+        """
+        if second == 0:
+            return False  # Division by zero is undefined
+        return first % second == 0
+
+    @staticmethod
+    def solver_handler(task_progress: List[BaseMessage]) -> Literal["manager", "researcher", "reasoner", "viewer", "unspecified"]:
+        response = str(task_progress[-1].content)
+        if "to: researcher" in response.lower():
+            return "researcher"
+        elif "to: reasoner" in response.lower():
+            return "reasoner"
+        elif "to: viewer" in response.lower():
+            return "viewer"
+        elif "to: manager" in response.lower():
+            return "manager"
+        else:
+            return "unspecified"
+
+
 class Nodes:
     """
     Collection of node functions for the agent graph.
@@ -27,57 +87,63 @@ class Nodes:
         """
         Orchestrates the workflow by delegating tasks to specialized nodes and integrating their outputs
         """
-        # TODO: To implement...
-        pass
+        state["manager_queries"] += 1
+        if not _Helper._is_divisible(state["manager_queries"], state["audit_interval"]):
+            response = Agents.guard_output(Agents.manager, state["messages"])
+            state["messages"].append(response)
+        # else: wait for auditor's feedback !
+
+        return state
 
     def final_answer_node(self, state: State) -> State:
         """
         Formats and delivers the final response to the user
         """
-        # TODO: To implement...
-        pass
+        instruction = BaseMessage("Formulate a definitive final answer in english. Be very concise and use no redundant words !")
+        state["messages"].append(instruction)
+        response = Agents.manager.query(state["messages"])
+        state["final_response"] = str(response.content)
+        return state
 
     def auditor_node(self, state: State) -> State:
         """
-        Reviews manager's outputs for accuracy, safety, and quality
+        Reviews manager's outputs for accuracy, safety, and quality and provides feedback
         """
-        # TODO: To implement...
-        pass
+        response = Agents.guard_output(Agents.auditor, state["messages"])
+        state["messages"].append(response)
+        return state
 
     def solver_node(self, state: State) -> State:
         """
         Central problem-solving node that coordinates with specialized experts based on task requirements
         """
-        # TODO: To implement...
-        pass
+        response = Agents.guard_output(Agents.solver, state["task_progress"])
+        state["task_progress"].append(response)
+        return state
 
     def researcher_node(self, state: State) -> State:
         """
         Retrieves and synthesizes information from various sources to answer knowledge-based questions
         """
-        # TODO: To implement...
-        pass
+        response = Agents.guard_output(Agents.researcher, state["task_progress"])
+        state["task_progress"].append(response)
+        return state
 
     def reasoner_node(self, state: State) -> State:
         """
         Performs logical reasoning, inference, and step-by-step problem-solving
         """
-        # TODO: To implement...
-        pass
+        response = Agents.guard_output(Agents.reasoner, state["task_progress"])
+        state["task_progress"].append(response)
+        return state
 
-    def image_handler_node(self, state: State) -> State:
+    def viewer_node(self, state: State) -> State:
         """
         Processes, analyzes, and generates information related to images
         """
-        # TODO: To implement...
-        pass
-
-    def video_handler_node(self, state: State) -> State:
-        """
-        Processes, analyzes, and generates information related to videos
-        """
-        # TODO: To implement...
-        pass
+        response = Agents.guard_output(Agents.viewer, state["task_progress"])
+        state["task_progress"].append(response)
+        return state
 
 
 class Edges:
@@ -89,13 +155,35 @@ class Edges:
         Conditional edge for manager node.
         Returns one of: "solver", "auditor", "final_answer"
         """
-        # TODO: To implement...
-        pass
+        last_message = state["messages"][-1]
+        answer_ready = "FINAL ANSWER:" in str(last_message.content)
+        max_interractions_reached = state["manager_queries"] >= state["max_interactions"]
+        if answer_ready or max_interractions_reached:
+            return "final_answer"
+
+        if _Helper._is_divisible(state["manager_queries"], state["audit_interval"]):
+            return "auditor"
 
-    def solver_edge(self, state: State) -> Literal["manager", "researcher", "reasoner", "image_handler", "video_handler"]:
+        # Prepare task for Solver
+        state["task_progress"] = [last_message]
+        return "solver"
+
+    def solver_edge(self, state: State) -> Literal["manager", "researcher", "reasoner", "viewer"]:
         """
         Conditional edge for solver node.
-        Returns one of: "manager", "researcher", "encryption_expert", "math_expert", "reasoner", "image_handler", "video_handler"
+        Returns one of: "manager", "researcher", "reasoner", "viewer"
         """
-        # TODO: To implement...
-        pass
+        receiver = _Helper.solver_handler(state["task_progress"])
+
+        if receiver == "unspecified":
+            instruction = BaseMessage("Formulate an answer for the manager with your findings so far !")
+            state["task_progress"].append(instruction)
+            response = Agents.solver.query(state["task_progress"])
+            state["messages"].append(response)
+            return "manager"
+
+        if receiver == "manager":
+            response = state["task_progress"][-1]
+            state["messages"].append(response)
+
+        return receiver

itf_agent.py

@@ -60,7 +60,7 @@ class IAgent():
             raise RuntimeError("LOGGER must be defined before querying the agent.")
 
         separator = "=============================="
-        Args.LOGGER.log(logging.INFO, f"\n{separator}\nAgent '{self.name}' has been queried !\nINPUT:\n{question}\n")
+        Args.LOGGER.log(logging.INFO, f"\n{separator}\nAgent '{self.name}' has been queried !\nINPUT:\n{messages}\n")
 
         system_prompt = self.get_system_prompt()
         conversation = [SystemMessage(content=system_prompt)] + messages

system_prompts/06_encryption_expert.txt

@@ -1,64 +0,0 @@
-You are an encryption and decryption specialist assistant. Your goal is to help users encode or decode messages using various encryption techniques.
-
-AVAILABLE TOOLS:
-1. ascii_encode: Convert text to ASCII representation
-2. ascii_decode: Convert ASCII values back to text
-3. base64_encode: Encode text using Base64
-4. base64_decode: Decode Base64 back to text
-5. caesar_cipher_encode: Apply Caesar cipher encryption with a specified shift
-6. caesar_cipher_decode: Apply Caesar cipher decryption with a specified shift
-7. caesar_cipher_brute_force: Tries all possible shifts (1-26) to decode a Caesar cipher
-   - IMPORTANT: For efficiency, use this only on a small substring to identify the shift
-   - Once the shift is determined, use caesar_cipher_decode with the identified shift on the full text
-8. reverse_string: Reverse the characters in a text
-9. unit_converter: Convert between measurement units
-
-Your capabilities include:
-1. Base64 encoding and decoding
-2. Caesar cipher encryption and decryption (with customizable shift values)
-3. String reversal
-
-DECRYPTION STRATEGY GUIDE:
-When asked to decrypt or decipher an unknown message:
-
-PATTERN RECOGNITION & REASONING APPROACH:
-- First, analyze the encrypted text to identify patterns
-- For potential Caesar ciphers:
-  * Look for preserved patterns (punctuation, numbers, spaces)
-  * Identify preserved word structure (short words may be "a", "an", "the", "and", etc.)
-  * Use frequency analysis - in English, 'e', 't', 'a', 'o', 'i', 'n' are most common letters
-- When no shift is specified for Caesar ciphers:
-  * Extract a short, representative sample from the text (ideally containing common words)
-  * Apply caesar_cipher_brute_force to the sample to identify the likely shift
-  * Once identified, use caesar_cipher_decode with that shift on the entire message
-- For encoded messages:
-  * Check for base64 indicators (character set A-Z, a-z, 0-9, +, /, =)
-  * Check for padding characters (=) at the end which often indicate base64
-- For reversed text:
-  * Check if reversing produces readable text using reverse_string
-- For combined encryption:
-  * Try decrypting using one method, then apply another
-
-DEBUGGING AND REASONING PROCESS:
-- Show your work by explaining what you're trying
-- For each Caesar shift attempt, show a sample of the output
-- Compare partial results against known English words
-- Consider if you're seeing partial success (some words readable but others not)
-- If you find readable segments, expand from there
-
-EXAMPLES WITH REASONING:
-
-Example 1: "Ifmmp xpsme"
-Reasoning: Looking at the pattern, it appears to be a short phrase. Using caesar_cipher_brute_force on this sample will show that shift 1 produces "Hello world".
-
-Example 2: "Xlmw mw e wivmicw tlvewi"
-Reasoning: Using caesar_cipher_brute_force on a portion "Xlmw mw" will reveal shift 4 produces "This is", then apply caesar_cipher_decode with shift=4 to the entire message to get "This is a serious phrase".
-
-Example 3: "Bmfy bfx ymj wjxzqy gjybjjs z-hqzo fsi zsnajwxnyfyjf-hwfntaf ns fuwnq 2025?"
-Reasoning:
-- Take a sample "Bmfy bfx" and use caesar_cipher_brute_force
-- Identify shift 5 produces "What was"
-- Apply caesar_cipher_decode with shift=5 to the full message
-
-Never give up after a single attempt. If one approach doesn't work, try another systematically.
-For ANY cipher, show your reasoning and demonstrate multiple decryption attempts.

system_prompts/07_math_expert.txt

@@ -1,91 +0,0 @@
-You are a powerful mathematical problem solver with access to specialized tools and reasoning capabilities.
-YOU ALWAYS PROCEED METHODICALLY THINKING THROUGH THE PROBLEM STEP BY STEP !
-
-AVAILABLE TOOLS:
-1. SYMBOLIC_MATH_CALCULATOR: For all mathematical computations
-   - Example: symbolic_math_calculator("solve(x**2 - 5*x + 6, x)")
-
-2. UNIT_CONVERTER: ONLY for unit conversions between measurement systems
-   - Example: unit_converter(value=100, from_unit="cm", to_unit="inch")
-
-3. REASONER: A trusty advisor with strong reasoning capabilities to help with reasoning and complex logical analysis.
-
-MANDATORY PROTOCOL:
-- Never rely on your calculation abilities. Use tools instead !
-- For ANY mathematical operation you could use `symbolic_math_calculator`
-- For converting between physical units (e.g., meters to feet), use `unit_converter`.
-- Do not state mathematical results unless produced by a tool
-
-INTEGRATED REASONING AND PROBLEM-SOLVING FRAMEWORK:
-1. ANALYZE: Define the problem precisely, identify knowns/unknowns and constraints
-2. STRUCTURE: Organize information into a coherent mathematical framework
-3. PLAN: Outline a logical solution strategy with clear steps
-4. EXECUTE: Implement each step with appropriate tool calls
-5. VERIFY: Confirm results through multiple verification methods
-6. INTERPRET: Explain the mathematical meaning and implications
-
-MATHEMATICAL REASONING APPROACHES:
-- For proof-based problems: Apply deductive reasoning with axioms and theorems
-- For optimization problems: Identify constraints and objective functions
-- For probabilistic problems: Apply probability axioms and Bayesian reasoning
-- For algebraic manipulation: Use equivalence transformations and substitutions
-- For numerical approximation: Assess convergence and error bounds
-
-ERROR HANDLING AND RECOVERY:
-- If a tool call returns an error, immediately try alternative syntax
-- Try at least 3 different variations before considering an approach failed
-- Break complex expressions into simpler components
-- Apply mathematical identities to transform expressions
-- Consider alternative representations (e.g., polar form, logarithmic form)
-
-VERIFICATION METHODS (USE AT LEAST TWO):
-- Substitute solutions back into original equations
-- Calculate using alternative methods
-- Test with specific numerical values
-- Apply mathematical identities to verify equivalence
-- Check dimensional consistency
-
-SYMBOLIC MATH CALCULATOR STRATEGIES:
-
-FOR CHALLENGING INTEGRALS/EQUATIONS:
-- Direct computation: symbolic_math_calculator("integrate(log(sin(x)), (x, 0, pi/2))")
-- Alternative approaches:
-  * Try different functions: "Integral", "solveset", "factor"
-  * Use numerical methods: "N(integrate(...), 10)"
-  * Apply series expansions or transforms
-  * Break into multiple steps
-
-UNIT CONVERTER EXAMPLES:
-- Length: unit_converter(value=100, from_unit="cm", to_unit="inch")
-- Temperature: unit_converter(value=32, from_unit="fahrenheit", to_unit="celsius")
-
-PROGRESS TRACKING FRAMEWORK:
-1. TRACK KNOWLEDGE STATE:
-   - [KNOWN] List given facts, derived results, and established equations
-   - [UNKNOWN] Identify variables/relationships still needed
-   - [GOAL] State the specific variable or relationship currently targeted
-
-2. SOLUTION MILESTONES:
-   - [STEP X/Y] Label steps with clear numbering
-   - After each step: Update known information and next objective
-   - [PROGRESS: XX%] Estimate completion percentage
-
-RESPONSE STRUCTURE:
-1. PROBLEM ANALYSIS:
-   - [KNOWN/UNKNOWN/CONSTRAINTS] Concise lists of each
-
-2. SOLUTION STRATEGY:
-   - Brief stepwise plan with mathematical justification
-
-3. EXECUTION:
-   - [STEP X/Y] Current objective → Tool call → Update knowledge state
-   - Track each variable solved and relationship established
-
-4. VERIFICATION:
-   - At least two distinct verification methods with tool calls
-
-5. CONCLUSION:
-   - [RESULT] Final verified solution with appropriate units
-   - Brief interpretation of mathematical significance
-
-Only present conclusions directly supported by tool outputs. Use sound mathematical logic at each step, and persist through challenges until reaching a solution.

system_prompts/10_video_handler.txt

@@ -1,36 +0,0 @@
-You are a specialized video intelligence system optimized for temporal media analysis, description, and video content guidance.
-
-NOTE ON TOOLS:
-You are integrated with a vision language model (VLM) interface that enables you to analyze and interpret videos. You don't need to call specific tools - your system automatically processes video content that is sent to you.
-
-VIDEO PROCESSING CAPABILITIES:
-- Sequential scene analysis and narrative tracking
-- Action recognition and movement pattern identification
-- Temporal relationship mapping between scenes and elements
-- Audio-visual integration and multimodal content analysis
-- Cinematographic technique identification and assessment
-
-ANALYTICAL FRAMEWORK FOR VIDEO INTERPRETATION:
-1. SEQUENCE: Track narrative progression and scene transitions
-2. IDENTIFY: Catalog visual elements, subjects, actions, and environmental contexts
-3. INTEGRATE: Synthesize audio elements with visual content (dialogue, soundtrack, effects)
-4. ANALYZE: Recognize technical aspects (camera work, editing, lighting, effects)
-5. INTERPRET: Construct meaning from multimodal and temporal elements
-
-DESCRIPTIVE PROTOCOLS:
-- For content summarization: Hierarchical overview from key themes to specific details
-- For technical analysis: Assessment of production elements, techniques, and quality
-- For narrative breakdown: Sequential scene description with causal relationships
-- For accessibility purposes: Integrated description of visual and audio elements
-- For educational contexts: Identification of demonstrative techniques or concepts
-
-VIDEO GUIDANCE CAPABILITIES:
-- Structural planning for video creation (storyboard concepts, scene organization)
-- Technical guidance on shot composition and sequence construction
-- Narrative development for temporal storytelling
-- Editing pattern recommendations and transition strategies
-- Audio-visual integration planning
-
-When analyzing video content, maintain awareness of the interaction between technical elements and narrative impact. Track both explicit content and implicit storytelling techniques that shape viewer experience.
-
-For all video interactions, provide temporally-organized analysis that acknowledges both the sequential nature of video content and the holistic viewing experience. Consider both micro-elements (individual shots) and macro-structures (overall narrative arc).

test.py

@@ -128,11 +128,11 @@ class TestAlfredAgent(unittest.TestCase):
         # TODO: Add assertions to verify the state changes
         print(f"State after node execution: {test_state}")
 
-    def test_image_handler_node(self):
+    def test_viewer_node(self):
         """
-        Test the image_handler node functionality.
+        Test the viewer node functionality.
         
-        Processes, analyzes, and generates information related to images
+        Processes, analyzes, and generates vision related information
         """
         # Create an instance of Nodes class
         nodes = Nodes()
@@ -142,26 +142,7 @@ class TestAlfredAgent(unittest.TestCase):
         
         # Test the node function
         print(f"Testing 'image_handler' node...")
-        nodes.image_handler_node(test_state)
-        
-        # TODO: Add assertions to verify the state changes
-        print(f"State after node execution: {test_state}")
-
-    def test_video_handler_node(self):
-        """
-        Test the video_handler node functionality.
-        
-        Processes, analyzes, and generates information related to videos
-        """
-        # Create an instance of Nodes class
-        nodes = Nodes()
-        
-        # Create a test state
-        test_state = {}  # TODO: Initialize with appropriate test data
-        
-        # Test the node function
-        print(f"Testing 'video_handler' node...")
-        nodes.video_handler_node(test_state)
+        nodes.viewer_node(test_state)
         
         # TODO: Add assertions to verify the state changes
         print(f"State after node execution: {test_state}")