minor refactoring

agents.py

@@ -1,23 +1,14 @@
 from args import Args
 from itf_agent import IAgent
-from llm_factory import AgentPreset
 from toolbox import Toolbox
 
 
-PRIMARY_AGENT_PRESET = AgentPreset(Args.primary_llm_interface, Args.primary_model,
-    temperature = None, max_tokens = 2048, repeat_penalty = None)
-SECONDARY_AGENT_PRESET = AgentPreset(Args.primary_llm_interface, Args.secondary_model,
-    temperature = None, max_tokens = 2048, repeat_penalty = None)
-VISION_AGENT_PRESET = AgentPreset(Args.vlm_interface, Args.vision_model,
-    temperature = None, max_tokens = 2048, repeat_penalty = None)
-
-
 class Manager(IAgent):
     """
     Orchestrates the workflow by delegating tasks to specialized nodes and integrating their outputs
     """
     def __init__(self):
-        super().__init__("01_manager.txt", PRIMARY_AGENT_PRESET)
+        super().__init__("01_manager.txt", Args.PRIMARY_AGENT_PRESET)
 
 
 class Auditor(IAgent):
@@ -25,7 +16,7 @@ class Auditor(IAgent):
     Reviews manager's outputs for accuracy, safety, and quality
     """
     def __init__(self):
-        super().__init__("02_auditor.txt", PRIMARY_AGENT_PRESET)
+        super().__init__("02_auditor.txt", Args.PRIMARY_AGENT_PRESET)
 
 
 class Summarizer(IAgent):
@@ -33,7 +24,7 @@ class Summarizer(IAgent):
     Generates concise summaries of conversations or passages.
     """
     def __init__(self):
-        super().__init__("03_summarizer.txt", PRIMARY_AGENT_PRESET)
+        super().__init__("03_summarizer.txt", Args.PRIMARY_AGENT_PRESET)
 
 
 class Solver(IAgent):
@@ -41,7 +32,7 @@ class Solver(IAgent):
     Central problem-solving node that coordinates with specialized experts based on task requirements
     """
     def __init__(self):
-        super().__init__("04_solver.txt", PRIMARY_AGENT_PRESET)
+        super().__init__("04_solver.txt", Args.PRIMARY_AGENT_PRESET)
 
 
 class Researcher(IAgent):
@@ -55,7 +46,7 @@ class Researcher(IAgent):
             toolbox.duckduckgo_images_search,
             toolbox.duckduckgo_videos_search
             ]
-        super().__init__("05_researcher.txt", PRIMARY_AGENT_PRESET, tools)
+        super().__init__("05_researcher.txt", Args.PRIMARY_AGENT_PRESET, tools)
 
 
 class Reasoner(IAgent):
@@ -77,7 +68,7 @@ class Reasoner(IAgent):
             encryption_toolbox.caesar_cipher_brute_force,
             encryption_toolbox.reverse_string
             ]
-        super().__init__("06_reasoner.txt", PRIMARY_AGENT_PRESET, tools)
+        super().__init__("06_reasoner.txt", Args.PRIMARY_AGENT_PRESET, tools)
 
 
 class Viewer(IAgent):
@@ -85,7 +76,7 @@ class Viewer(IAgent):
     Processes, analyzes, and generates information related to images
     """
     def __init__(self):
-        super().__init__("07_viewer.txt", VISION_AGENT_PRESET)
+        super().__init__("07_viewer.txt", Args.VISION_AGENT_PRESET)
 
 
 class OutputGuard(IAgent):
@@ -93,4 +84,4 @@ class OutputGuard(IAgent):
     Performs logical reasoning, inference, and step-by-step problem-solving
     """
     def __init__(self):
-        super().__init__("08_output_guard.txt", SECONDARY_AGENT_PRESET)
+        super().__init__("08_output_guard.txt", Args.SECONDARY_AGENT_PRESET)

alfred.py

@@ -1,22 +1,12 @@
-from typing import Dict, Any
+from langchain_core.messages import BaseMessage
+
+from typing import Any, Dict
 
 from args import Args
 from graph import State
 from graph_builder import GraphBuilder
 
 
-# Maximum number of interactions between Assistant and Manager
-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:
-TEMPERATURE = 0.7
-MAX_TOKENS = 2000
-
-
 class Alfred:
 
     def __init__(self):
@@ -25,15 +15,15 @@ class Alfred:
         self.graph_builder = GraphBuilder()
         self.agent_graph = self.graph_builder.build_agent_graph()
 
-    async def __call__(self, question: str) -> str:
+    def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        result = await self.process_query(question)
+        result = self.process_query(question)
         response = result["final_response"]
         print(f"Agent processed the response: {response}")
 
         return response
 
-    async def process_query(self, query: str) -> Dict[str, Any]:
+    def process_query(self, query: str) -> Dict[str, Any]:
         """
         Process a query through the agent graph.
 
@@ -45,10 +35,15 @@ class Alfred:
         """
         initial_state: State = {
             "initial_query": query,
-            "messages": [],
-            "nr_interactions": 0,
+            "messages": [BaseMessage(query)],  # Manager's context
+            "task_progress": [],  # Solver's context
+            "audit_interval": Args.AlfredParams.AUDIT_INTERVAL,
+            "manager_queries": 0,
+            "solver_queries": 0,
+            "max_interactions": Args.AlfredParams.MAX_INTERACTIONS,
+            "max_solving_effort": Args.AlfredParams.MAX_SOLVING_EFFORT,
             "final_response": None
         }
 
-        result = await self.agent_graph.ainvoke(initial_state)
+        result = self.agent_graph.invoke(initial_state)
         return result

app.py

@@ -52,6 +52,7 @@ class Application:
         """
 
         print(f"Fetching questions from: {self.questions_url}")
+        response = None
         try:
             response = requests.get(self.questions_url, timeout=15)
             response.raise_for_status()
@@ -62,7 +63,8 @@ class Application:
             print(f"Fetched {len(questions_data)} questions.")
         except requests.exceptions.JSONDecodeError as e:
             print(f"Error decoding JSON response from questions endpoint: {e}")
-            print(f"Response text: {response.text[:500]}")
+            if response:
+                print(f"Response text: {response.text[:500]}")
             return f"Error decoding server response for questions: {e}", None
         except requests.exceptions.RequestException as e:
             print(f"Error fetching questions: {e}")
@@ -73,7 +75,7 @@ class Application:
         return questions_data
 
     @staticmethod
-    async def _run_agent(questions_data, agent):
+    def _run_agent(questions_data, agent):
         """
         Runs the agent on a list of questions and collects results.
 
@@ -99,7 +101,7 @@ class Application:
                 print(f"Skipping item with missing task_id or question: {item}")
                 continue
             try:
-                submitted_answer = await agent(question_text)
+                submitted_answer = agent(question_text)
                 print(f"SUBMITED_ANSWER: {submitted_answer}")
                 answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
                 results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
@@ -127,17 +129,18 @@ class Application:
         print(f"Submitting {len(answers_payload)} answers to: {self.submit_url}")
         try:
             if MOCK_SUBMISSION:
-                mock_response = type('MockResponse', (), {
-                    'status_code': 200,
-                    'json': lambda *args: {
-                        "username": self.username,
-                        "score": 100,
-                        "correct_count": len(answers_payload),
-                        "total_attempted": len(answers_payload),
-                        "message": "Mock submission successful."
-                    }
-                })
-                response = mock_response()
+                app_username = self.username
+                class MockResponse:
+                    status_code = 200
+                    def json(self):
+                        return {
+                            "username": app_username,
+                            "score": 100,
+                            "correct_count": len(answers_payload),
+                            "total_attempted": len(answers_payload),
+                            "message": "Mock submission successful."
+                        }
+                response = MockResponse()
             else:
                 response = requests.post(self.submit_url, json=submission_data, timeout=60)
                 response.raise_for_status()
@@ -179,7 +182,7 @@ class Application:
             results_df = pd.DataFrame(results_log)
             return status_message, results_df
 
-    async def eval_and_submit_all(self, profile: gr.OAuthProfile | None):
+    def eval_and_submit_all(self, profile: gr.OAuthProfile | None):
         """
         Fetches all questions, runs the agent on them, submits all answers,
         and displays the results.
@@ -202,7 +205,7 @@ class Application:
         questions_data = self._fetch_questions()
 
         # 3. Run your Agent
-        results_log, answers_payload = await self._run_agent(questions_data, agent)
+        results_log, answers_payload = self._run_agent(questions_data, agent)
 
         if not answers_payload:
             print("Agent did not produce any answers to submit.")

args.py

@@ -1,5 +1,5 @@
-
 from enum import Enum
+from typing import Optional
 
 from logger import Logger
 
@@ -10,6 +10,71 @@ class LLMInterface(Enum):
     # Add your own if you like (then adjust the LLMFactory)
 
 
+class AgentPreset:
+    def __init__(self, interface: LLMInterface, model_name: str, temperature: Optional[float] = None, 
+                 max_tokens: Optional[int] = None, repeat_penalty: Optional[float] = None):
+        """
+        Initialize an AgentPreset with LLM configuration parameters.
+        
+        Args:
+            interface: The model interface to use (e.g., OPENAI, HUGGINGFACE)
+            model_name: Name of the model to use
+            temperature: Controls randomness in responses (0.0-1.0)
+            max_tokens: Maximum number of tokens to generate in response
+            repeat_penalty: Penalty for token repetition
+        """
+        self.interface = interface
+        self.model_name = model_name
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.repeat_penalty = repeat_penalty
+    
+    def get_interface(self) -> LLMInterface:
+        """
+        Get the model interface.
+        
+        Returns:
+            LLMInterface: The interface used for this agent.
+        """
+        return self.interface
+    
+    def get_model_name(self) -> str:
+        """
+        Get the model name.
+        
+        Returns:
+            str: The name of the model.
+        """
+        return self.model_name
+    
+    def get_temperature(self) -> float | None:
+        """
+        Get the temperature setting.
+        
+        Returns:
+            float: The temperature value controlling randomness.
+        """
+        return self.temperature
+    
+    def get_max_tokens(self) -> int | None:
+        """
+        Get the maximum tokens setting.
+        
+        Returns:
+            int: The maximum number of tokens for generation.
+        """
+        return self.max_tokens
+    
+    def get_repeat_penalty(self) -> float | None:
+        """
+        Get the repeat penalty setting.
+        
+        Returns:
+            float: The penalty value for token repetition.
+        """
+        return self.repeat_penalty
+
+
 class Args:
     LOGGER = Logger.set_logger()
     primary_llm_interface=LLMInterface.OPENAI
@@ -21,3 +86,23 @@ class Args:
     api_base="http://127.0.0.1:1234/v1"  # LM Studio local endpoint
     api_key=None
     token = ""  # Not needed when using OpenAILike API
+    # Agent presets
+    PRIMARY_AGENT_PRESET = AgentPreset(
+        primary_llm_interface, primary_model,
+        temperature = None, max_tokens = 2048, repeat_penalty = None
+        )
+    SECONDARY_AGENT_PRESET = AgentPreset(
+        primary_llm_interface, secondary_model,
+        temperature = None, max_tokens = 2048, repeat_penalty = None
+        )
+    VISION_AGENT_PRESET = AgentPreset(
+        vlm_interface, vision_model,
+        temperature = None, max_tokens = 2048, repeat_penalty = None
+        )
+    class AlfredParams:
+        # Maximum number of interactions between Manager and Solver
+        MAX_INTERACTIONS = 6
+        # Maximum number of interactions between Solver and it's assistants
+        MAX_SOLVING_EFFORT = 6
+        # Verification happening every few messages to see whether the manager agent got stuck
+        AUDIT_INTERVAL = 3

itf_agent.py

@@ -5,8 +5,8 @@ import os
 import re
 from typing import List
 
-from args import Args
-from llm_factory import LLMFactory, AgentPreset
+from args import Args, AgentPreset
+from llm_factory import LLMFactory
 
 
 class IAgent():

llm_factory.py

@@ -1,74 +1,7 @@
 from langchain_huggingface import ChatHuggingFace, HuggingFaceEndpoint
 from langchain_openai import ChatOpenAI
 
-from typing import Optional
-
-from args import LLMInterface, Args
-
-
-class AgentPreset:
-    def __init__(self, interface: LLMInterface, model_name: str, temperature: Optional[float] = None, 
-                 max_tokens: Optional[int] = None, repeat_penalty: Optional[float] = None):
-        """
-        Initialize an AgentPreset with LLM configuration parameters.
-        
-        Args:
-            interface: The model interface to use (e.g., OPENAI, HUGGINGFACE)
-            model_name: Name of the model to use
-            temperature: Controls randomness in responses (0.0-1.0)
-            max_tokens: Maximum number of tokens to generate in response
-            repeat_penalty: Penalty for token repetition
-        """
-        self.interface = interface
-        self.model_name = model_name
-        self.temperature = temperature
-        self.max_tokens = max_tokens
-        self.repeat_penalty = repeat_penalty
-    
-    def get_interface(self) -> LLMInterface:
-        """
-        Get the model interface.
-        
-        Returns:
-            LLMInterface: The interface used for this agent.
-        """
-        return self.interface
-    
-    def get_model_name(self) -> str:
-        """
-        Get the model name.
-        
-        Returns:
-            str: The name of the model.
-        """
-        return self.model_name
-    
-    def get_temperature(self) -> float:
-        """
-        Get the temperature setting.
-        
-        Returns:
-            float: The temperature value controlling randomness.
-        """
-        return self.temperature
-    
-    def get_max_tokens(self) -> int:
-        """
-        Get the maximum tokens setting.
-        
-        Returns:
-            int: The maximum number of tokens for generation.
-        """
-        return self.max_tokens
-    
-    def get_repeat_penalty(self) -> float:
-        """
-        Get the repeat penalty setting.
-        
-        Returns:
-            float: The penalty value for token repetition.
-        """
-        return self.repeat_penalty
+from args import LLMInterface, Args, AgentPreset
 
 
 class LLMFactory():