bugfixes

Author: C0deMunk33

agent_orchestrator.py

@@ -21,30 +21,34 @@ def __init__(self, server_url: str, model: str):
         self.model = model
         self.running = True
 
+        self.tool_schemas = []
+
     def add_agent(self, agent: Agent):
         self.agents.append(agent)
 
-    def run(self, tool_callback: Callable, app_managers: List[AppManager]):
+    def run(self, tool_callback: Callable, post_system_tool_calls: List[ToolCall]):
         while self.running:
-            for agent in self.agents:
+            for agent_index, agent in enumerate(self.agents):
                 print("~"*100)
+                print("###AGENT RUN STARTING###")
+                print(f"###{agent_index}###")
                 print(f"Running agent: {agent.name} \n")
 
                 post_system_messages = []
-                # make assistant messages for loaded apps
-                agent_app_manager = app_managers[agent.id]
-                get_loaded_apps_tool_call = ToolCall(
-                    toolset_id="app_manager",
-                    name="get_loaded_apps",
-                    arguments={}
-                )
-                get_loaded_apps_tool_call_result = agent_app_manager.agent_tool_callback(agent, get_loaded_apps_tool_call)
-                
-                post_system_messages.append(Message(role="assistant", tool_calls=[get_loaded_apps_tool_call]))
-                post_system_messages.append(Message(role="tool", content=get_loaded_apps_tool_call_result))
+                print(f"Post system tool calls:")
+                for tool_call in post_system_tool_calls:
+                    tool_call_result = tool_callback(agent, tool_call)
+                    post_system_messages.append(Message(role="tool", content=tool_call_result))
 
                 agent.run(self.server_url, self.model, post_system_messages, tool_callback)
-
+                print("###AGENT RUN COMPLETE###")
+                print(f"###{agent_index}###")
+
+            
+            # if all agents are complete, stop
+            if all(not agent.running for agent in self.agents):
+                self.running = False
+                break
     def stop(self):
         self.running = False
 
@@ -77,32 +81,6 @@ def get_agent_status(self):
             "running": self.get_running_agent_count(),
             "stopped": self.get_stopped_agent_count()
         }
-    
-    ############### Agent Interface ###############
-    def get_toolset_details(self):
-        return ToolsetDetails(
-            toolset_id="agent_tool",
-            name="Agent Orchestrator",
-            description="Orchestrates agents"
-        )
-
-    def get_tool_schemas(self):
-        tool_schemas = [{
-            "toolset_id": "agent_tool",
-            "name": "set_name",
-            "description": "Set your name",
-            "arguments": [{
-                "name": "name",
-                "type": "string",
-                "description": "your new name"
-            }]
-        }]
-        return tool_schemas
-    
-    def agent_tool_callback(self, agent: Agent, tool_call: ToolCall):
-        if tool_call.name == "set_name":
-            agent.name = tool_call.arguments["name"]
-            return f"Name set to {tool_call.arguments['name']}"
 
 def main():
     from tools.forum import Directory
@@ -113,6 +91,7 @@ def main():
     from tools.file_manager import FileManager
     from tools.persona import PersonaManager
     from tools.notes import NotesManager
+    from tools.user_directory import UserDirectory
     # delete out files if they exist
     if os.path.exists("std_out.txt"):
         os.remove("std_out.txt")
@@ -144,14 +123,13 @@ def main():
     notes_managers = {}
     orchestrator = AgentOrchestrator(server_url="http://localhost:5000", model="llama3.1:8b")
     wiki_search = WikiSearch()
+    user_directory = UserDirectory()
     def tool_callback(agent: Agent, tool_call: ToolCall):
         tool_results = None
         print(f"  - {tool_call.toolset_id} - Tool call: {tool_call}")
         try:
             if tool_call.toolset_id == "forum_toolset":
                 tool_results = forum_directory.agent_tool_callback(agent, tool_call)
-            elif tool_call.toolset_id == "agent_tool":
-                tool_results = orchestrator.agent_tool_callback(agent, tool_call)
             elif tool_call.toolset_id == "code_runner":
                 tool_results = shared_code_runner.agent_tool_callback(agent, tool_call)
             elif tool_call.toolset_id == "wiki_toolset":
@@ -166,6 +144,8 @@ def tool_callback(agent: Agent, tool_call: ToolCall):
                 tool_results = persona_managers[agent.id].agent_tool_callback(agent, tool_call)
             elif tool_call.toolset_id == "notes_manager":
                 tool_results = notes_managers[agent.id].agent_tool_callback(agent, tool_call)
+            elif tool_call.toolset_id == "messages":
+                tool_results = user_directory.agent_tool_callback(agent, tool_call)
             else:
                 print(f"APP NOT FOUND - toolset_id: {tool_call.toolset_id} not found")
         except Exception as e:
@@ -230,19 +210,14 @@ def tool_callback(agent: Agent, tool_call: ToolCall):
                 name="get_current_persona",
                 arguments={}
             ),
-            ToolCall(
-                toolset_id="notes_manager",
-                name="get_notes",
-                arguments={}
-            ),
             ToolCall(
                 toolset_id="quest_manager",
                 name="get_quest_list",
                 arguments={}
             ),
             ToolCall(
-                toolset_id="quest_manager",
-                name="get_current_quest",
+                toolset_id="messages",
+                name="get_new_message_count",
                 arguments={}
             ),
             ToolCall(
@@ -271,24 +246,40 @@ def tool_callback(agent: Agent, tool_call: ToolCall):
         quest_manager = QuestManager()
         quest_managers[agent.id] = quest_manager
 
+        user_directory.add_user(agent)
 
         app_manager.add_app(persona_manager.get_toolset_details(), persona_manager.get_tool_schemas())
-        app_manager.add_app(orchestrator.get_toolset_details(), orchestrator.get_tool_schemas())
         app_manager.add_app(shared_code_runner.get_toolset_details(), shared_code_runner.get_tool_schemas())
         app_manager.add_app(quest_manager.get_toolset_details(), quest_manager.get_tool_schemas())
-        app_manager.load_app(quest_manager.get_toolset_details().toolset_id)
+        #app_manager.load_app(quest_manager.get_toolset_details().toolset_id)
         app_manager.add_app(wiki_search.get_toolset_details(), wiki_search.get_tool_schemas())
         app_manager.add_app(forum_directory.get_toolset_details(), forum_directory.get_tool_schemas())
         app_manager.add_app(file_manager.get_toolset_details(), file_manager.get_tool_schemas())
         app_manager.add_app(notes_manager.get_toolset_details(), notes_manager.get_tool_schemas())
         app_manager.load_app(notes_manager.get_toolset_details().toolset_id)
+        app_manager.add_app(user_directory.get_toolset_details(), user_directory.get_tool_schemas())
         app_managers[agent.id] = app_manager
         orchestrator.add_agent(agent)
 
+    post_system_tool_calls = [
+        ToolCall(
+            toolset_id="app_manager",
+            name="get_loaded_apps",
+            arguments={}
+        ),
+        ToolCall(
+            toolset_id="quest_manager",
+            name="get_current_quest",
+            arguments={}
+        ),
+        ToolCall(
+            toolset_id="notes_manager",
+            name="get_notes",
+            arguments={}
+        )
+    ]
 
-
-
-    orchestrator.run(tool_callback=tool_callback, app_managers=app_managers)
+    orchestrator.run(tool_callback=tool_callback, post_system_tool_calls=post_system_tool_calls)
 
 if __name__ == "__main__":
     main()

libs/agent.py

@@ -25,6 +25,14 @@ class AgentSummarySchema(BaseModel):
     summary: str = Field(description="string of summary. This is a summary of the actions taken, including what was thought and what was done.")
     instructions_for_next_pass: str = Field(description="This is the prompt you will receive in the next pass as a user message.")
 
+class AgentRunOutput(BaseModel): # TODO: generate and save this for each pass
+    model: str = Field(description="The model used for the agent run.")
+    run_messages: List[Message] = Field(description="The messages from the agent run.")
+    agent_output: AgentOutputSchema = Field(description="The output of the agent run.")
+    summary_messages: List[Message] = Field(description="The messages from the summary pass.")
+    summary_output: AgentSummarySchema = Field(description="The output of the summary pass.")
+    tool_results: List[str] = Field(description="The results from the tool calls.")
+
 class Agent:
     def __init__(self, default_llm_url: str, name: str, private_key: str, initial_instructions: str, initial_notes: List[str], buffer_size: int = 20, running: bool = True, standing_tool_calls: List[ToolCall] = []):
         self.default_llm_url = default_llm_url
@@ -216,17 +224,20 @@ def run(self, llm_url: str, model: str, post_system_messages: List[Message], too
             raise e
         print()
         print(f"Thoughts:")
-        print(response.thoughts)
-        print(f"Followup thoughts:")
-        print(response.followup_thoughts)
+        print("    - " + response.thoughts)
+        print("    - " + response.followup_thoughts)
 
         if not response.should_continue:    
             self.running = False
 
         self.call_tools(response.tool_calls, tool_callback)
 
+        print("\n\nFull System Prompt:")
+        print(system_prompt)
         summary = self.get_pass_summary(llm_url, response, standing_tool_results)
-        
+        print("\n\nFull Summary:")
+        print(summary.model_dump_json(indent=4))
+
         self.pass_summaries.append(summary)
         self.notes.extend(summary.notes)
 

libs/app_manager.py

@@ -58,12 +58,12 @@ def list_apps(self):
             result += f"    [loaded] {app.toolset_id} - {app.name} - {app.description}\n"
         for app in unloaded_apps:
             result += f"    [unloaded] {app.toolset_id} - {app.name} - {app.description}\n"
-
+        print()
+        print(result)
         result += "\nApp Manager Tools:\n"
         for tool_schema in self.self_tool_schemas:
             result += f"  (toolset_id: {tool_schema.toolset_id}) {tool_schema.name}({",".join([arg['name'] for arg in tool_schema.arguments])}) - description: {tool_schema.description}\n"
-        print()
-        print(result)
+
         return result
 
     def load_app(self, app_id: str):
@@ -90,7 +90,7 @@ def unload_app(self, app_id: str):
         {
             "toolset_id": "app_manager",
             "name": "unload_app",
-            "description": "unloads an app.",
+            "description": "unloads an app. do this to free up memory and resources.",
             "arguments": [{
                 "name": "app_id",
                 "type": "string",
@@ -137,9 +137,15 @@ def get_loaded_apps(self):
         result += "(note: these are the only tools available to you at this time)\n"
         for app_id in self.loaded_app_ids:
             for schema in self.schemas[app_id]:
-                tool_schema = ToolSchema.model_validate_json(schema)
-                # arguments is a list of dictionaries
-                result += f"        toolset_id='{tool_schema.toolset_id}' name='{tool_schema.name}' description='{tool_schema.description}' arguments='{tool_schema.arguments}'\n"
+                try:
+                    tool_schema = ToolSchema.model_validate_json(schema)
+                    # arguments is a list of dictionaries
+                    result += f"        toolset_id='{tool_schema.toolset_id}' name='{tool_schema.name}' description='{tool_schema.description}' arguments='{tool_schema.arguments}'\n"
+                except Exception as e:
+                    print(f"Error validating tool schema: {e}")
+                    print(f"Schema: {schema}")
+                    print(type(schema))
+                    raise e
 
         return result
 

log_parser.py

@@ -0,0 +1,35 @@
+from pydantic import BaseModel
+
+log_file = "std_out.txt"
+
+class AgentRun(BaseModel):
+    agent_id: str
+    inner_text: str
+    is_complete: bool
+
+def parse_log_file(log_file: str):
+    agent_runs = {} # key is the line after "###AGENT RUN STARTING###", looks like "###0###", array of runs
+
+    with open(log_file, "r") as file:
+        lines = file.readlines()
+
+    previous_line = None
+    current_agent_id = None
+    for line in lines:
+        if previous_line is not None and "###AGENT RUN STARTING###" in previous_line:
+            current_agent_id = line.strip().split("###")[1]
+            if agent_runs.get(current_agent_id) is None:
+                agent_runs[current_agent_id] = []
+            agent_runs[current_agent_id].append(AgentRun(agent_id=current_agent_id, inner_text="", is_complete=False))
+        elif "###AGENT RUN COMPLETE###" in line:
+            agent_runs[current_agent_id][-1].is_complete = True
+            current_agent_id = None
+        elif current_agent_id is not None and not agent_runs[current_agent_id][-1].is_complete:
+            agent_runs[current_agent_id][-1].inner_text += line 
+
+        previous_line = line
+    return agent_runs
+
+agent_runs = parse_log_file(log_file)
+
+print(agent_runs["0"][-1].inner_text)