Update

.gitignore

@@ -1,2 +1,6 @@
 key_openai.txt
-/**/*/.env
+/**/*/.env
+*.pyc
+/**/*/agentsIds.env
+/**/*/__pycache__
+.vscode

README.md

@@ -5,8 +5,33 @@
 We have our first GPT Concierge. You can chat with this custom ChatGPT to figure out what's going on! 
 
 - **HAAS Board Concierge:** [https://chat.openai.com/g/g-MIssTuE2b-haas-board-concierge](https://chat.openai.com/g/g-MIssTuE2b-haas-board-concierge)
+- **HAAS Assistant:** [https://chat.openai.com/g/g-lIAp9qowx-haas-assistant](https://chat.openai.com/g/g-lIAp9qowx-haas-assistant) (Similar function as above but markedly faster)
 
-## Overview
+## Public Discord
+
+The Autonomous AI Lab discord for the ACE Framework and HAAS Project is now open: https://discord.gg/mJKUYNm8qY
+
+> !!!! IMPORTANT NOTE: This repo is still the single source of truth! If it's not on this repo, it doesn't exist! Discord is merely for convenience. 
+
+# Project Principles
+
+## Move Fast, Break Stuff
+
+This is first and foremost a high velocity hacking group. 
+
+## Cutting Edge Only
+
+Exclusively use cutting edge stuff, like OpenAI's latest Agents endpoint. For exclusively Open Source, go check out the ACE Framework: https://github.com/daveshap/ACE_Framework
+
+## Full Autonomy
+
+Fully autonomous swarms are the goal. That means a human does not need to be in the loop telling it what to do, supervising, or anything. Characteristics of a fully autonomous swarm:
+
+1. **Self-Directing:** Once instantiated, the swarm pursues its mission or goals without supervision. It may self-direct based on principles such as the heuristic imperatives, or by specific mission parameters.
+2. **Self-Correcting:** The swarm must detect and correct technical, strategic, epistemic, and other errors and then correct them.
+3. **Self-Improving:** Eventually, the swarm should enhance its own fundamental capabilities over time. 
+
+# Overview
 
 The Hierarchical Autonomous Agent Swarm (HAAS) is a groundbreaking initiative that leverages OpenAI's latest advancements in agent-based APIs to create a self-organizing and ethically governed ecosystem of AI agents. Drawing inspiration from the ACE Framework, HAAS introduces a novel approach to AI governance and operation, where a hierarchy of specialized agents, each with distinct roles and capabilities, collaborate to solve complex problems and perform a wide array of tasks.
 

agents/agent_builder/agents/Autonomous Swarm Agent Builder/settings.json

@@ -0,0 +1,6 @@
+{
+  "model": "gpt-4-1106-preview",
+  "description": "Foundation Swarm Builder",
+  "tools": [{ "type": "code_interpreter" }],
+  "metadata": {}
+}

agents/agent_builder/agents/temporary_function_writer/instructions.md

@@ -0,0 +1,16 @@
+# Mission
+- You will be provided JSON schema of an OpenAI function tool from an API and not a human user
+- The JSON will contain all information about the function and you will need to translate it into a python function.
+
+# Background info
+- None
+
+# Rules
+- Your response must only be a python markdown block containing the translated function 
+- The function must be fully implemented in python
+- The function should not contain pseudo code or placeholders
+
+# Instructions
+- Translate the JSON to a fully functioning python function
+- Return the python function in a markdown block
+- If you are unable to perform this translation return reply asking for additional info as arguments

agents/agent_builder/agents/temporary_function_writer/settings.json

@@ -0,0 +1,17 @@
+{
+  "model": "gpt-4-1106-preview",
+  "description": "Function writer",
+  "tools": [
+    { "type": "code_interpreter" },
+    {
+      "type": "function",
+      "function": {
+        "name": "get_existing_functions",
+        "description": "List available functions that can be called",
+        "parameters": { "type": "object", "properties": {} },
+        "required": []
+      }
+    }
+  ],
+  "metadata": {}
+}

agents/agent_builder/agents/tool_creator/instructions.md

@@ -0,0 +1,34 @@
+# Mission
+- Transcript a user's request into a valid schema to represent a valid function call
+
+# Background info
+None
+
+# Rules
+- Always check the provided files to ground your thoughts.
+- If a term can have multiple meanings, always prefer those mentioned in the provided documents.
+
+# Instructions
+- Initialize: Prepare to receive input for the creation of a new function using the request_function tool.
+- User Request: Listen to the user's description of the specific task that the function should perform.
+- Function Name: 
+    a. Derived from the task description, formulate a concise and descriptive function name. 
+    b. Aim for clarity and specificity to convey the function's purpose effectively.    
+- Function Description: 
+    a. Write a clear and precise description of the function's expected behavior. 
+    b. Include details about what the function will accomplish and any side effects. 
+    c. (Emphasize) Ensure that the description explicitly communicates the function's intended outcome to avoid ambiguity.
+- Input Arguments JSON Schema: 
+    a. Based on the requirements of the task, define the JSON schema for the input arguments. 
+    b. The schema should be comprehensive and must specify the types, required fields, and constraints for each input argument. 
+    c. Ensure that the schema aligns with the user's requirements and the function's intended behavior.
+- Validation: Cross-check the name, description, and JSON schema against the user's requirements to confirm accuracy and completeness.
+- Execution: Utilize the request_function tool with the following 
+    inputs:
+        name: [Function Name]
+        descriptions: [Function Description]
+        input_argument_json_schema: [Input Arguments JSON Schema]
+- Feedback Loop: Promptly present the newly created function specifications to the user for any feedback or necessary revisions.
+- Iterate: Make adjustments as requested by the user, refining the function name, description, and input argument schema until it meets the user's satisfaction.
+Finalize: Once the user gives approval, consider the function creation process complete.
+- Note: Remember to prioritize user requirements and emphasize clear communication in the function description, as highlighted by the user.

agents/agent_builder/agents/tool_creator/settings.json

@@ -0,0 +1,33 @@
+{
+  "model": "gpt-4-1106-preview",
+  "description": "assistant to demonstrate tool creation",
+  "tools": [
+    { "type": "code_interpreter" },
+    {
+      "type": "function",
+      "function": {
+        "name": "function_request",
+        "description": "request an authority to grant you access to a new function",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "name": {
+              "type": "string",
+              "description": "name of the function"
+            },
+            "description": {
+              "type": "string",
+              "description": "expected function behaviour"
+            },
+            "schema": {
+              "type": "string",
+              "description": "the input arguments for the requested function following the JOSN schema in a format ready to be serialized"
+            }
+          },
+          "required": ["name", "schema"]
+        }
+      }
+    }
+  ],
+  "metadata": {}
+}

agents/agent_builder/create.py

@@ -0,0 +1,164 @@
+import os
+import json
+from pathlib import Path
+from shared.openai_config import get_openai_client
+
+class AgentBuilder:
+
+    def __init__(self,client):
+        self.client = client
+        self.existing_assistants = {}
+        self.agents_path = "agents"
+
+    def get_existing_assistants(self):
+        if not self.existing_assistants:
+            for assistant in  self.client.beta.assistants.list(limit=100):
+                self.existing_assistants[assistant.name] = assistant
+
+    def create_assistant(self, agent_name):
+        current_file_path = Path(__file__).absolute().parent
+        agent_folder = os.path.join(current_file_path, self.agents_path, agent_name)
+
+        if (
+            not os.path.exists(agent_folder)
+            or not os.path.isdir(agent_folder)
+            or not os.listdir(agent_folder)
+        ):
+            raise ValueError(f'{agent_folder} is missing, not a directory, or empty.')
+
+        print(agent_folder)
+        existing_files = {}
+        requested_files = []
+        existing_agent = {}
+        self.get_existing_assistants()
+        if agent_name in self.existing_assistants:
+            existing_agent = self.existing_assistants[agent_name]    
+            for file_id in existing_agent.file_ids:
+                existing_file = self.client.files.retrieve(file_id=file_id)
+                existing_files[existing_file.filename] = existing_file
+
+
+        if os.path.isdir(agent_folder):
+            # Read contents from the 'instructions.md' file
+            instructions = ""
+            instructions_file_path = os.path.join(agent_folder, "instructions.md")
+            if os.path.isfile(instructions_file_path):
+                with open(instructions_file_path, 'r') as f:
+                    instructions = f.read()
+
+            # Read contents from the 'settings.json' file
+            settings = {}
+            settings_file_path = os.path.join(agent_folder, 'settings.json')
+            if os.path.isfile(settings_file_path):
+                with open(settings_file_path, 'r') as f:
+                    settings = json.load(f)
+
+            # Check for the 'files' subfolder and process its contents
+            files = []
+            files_folder = os.path.join(agent_folder, 'files')
+            if os.path.isdir(files_folder):
+                for filename in os.listdir(files_folder):
+                    requested_files.append(filename)
+                    # Doesn't handle if file has been modified
+                    if filename not in existing_files:
+                        file_path = os.path.join(files_folder, filename)
+                        with open(file_path, 'rb') as file_data:
+                            # Upload each file to OpenAI
+                            file_object = self.client.files.create(
+                                file=file_data, purpose='assistants'
+                            )
+                            files.append({"name": filename, "id": file_object.id})        
+
+            print(agent_name)
+            print("")
+            print(instructions)
+            if files:
+                print("")
+                print(f"Files: {list(map(lambda x: x['name'], files))}")
+
+            assistant={}
+
+            if existing_agent:
+                print(f"{agent_name} already exists... validating properties")
+                update_model = existing_agent.model != settings["model"]
+                update_description = existing_agent.description != settings["description"]
+                update_instructions = existing_agent.instructions != instructions
+                existing_agent_tools_raw = list(filter(lambda item: item.type ==  "function", existing_agent.tools))
+                existing_agent_tools = [ ({ 'type': item.type, 'function': { 'name': item.function.name, 'description': item.function.description, 'parameters': item.function.parameters } }) for item in existing_agent_tools_raw ]
+                setting_agent_tools = list(filter(lambda item: item["type"] ==  "function", settings["tools"]))
+                update_tools = existing_agent_tools != setting_agent_tools
+
+                update_params = {}
+
+                requested_files_set = set(requested_files)
+                existing_files_set = set(existing_files.keys())
+
+                if update_model:
+                    update_params["model"] = settings["model"]
+                if update_instructions:
+                    update_params["instructions"] = instructions
+                if update_description:
+                    update_params["description"] = settings["description"]
+                if files or requested_files_set != existing_files_set:
+                   retained_set = existing_files_set.intersection(requested_files_set)
+                   all_file_ids = []
+                   for key in retained_set:
+                       all_file_ids.append(existing_files[key].id)
+                   all_file_ids += list(map(lambda x: x['id'], files))
+                   update_params['file_ids'] = all_file_ids
+                   if not any( tool.type == "retrieval" for tool in existing_agent.tools):
+                      update_params['tools'] = existing_agent.tools
+                      update_params['tools'].append({'type': 'retrieval'})
+                if update_tools:
+                    update_params['tools'] = settings["tools"]
+                    if len(requested_files) > 0:
+                        update_params['tools'].append({'type': 'retrieval'})
+
+                if len(update_params) != 0:
+                    print(f"Updating {agent_name}'s { ','.join(update_params.keys()) }") 
+                    update_params['assistant_id'] = existing_agent.id
+                    assistant = self.client.beta.assistants.update(**update_params)
+                else:
+                  print(f"{agent_name} is up to date")         
+            else:        
+
+                create_params = {
+                    "name": agent_name,
+                    "instructions": instructions,
+                    "description": settings["description"],
+                    "model": settings["model"],
+                    "tools": settings["tools"]
+                }
+
+                # Only include 'file_ids' if there are files
+                if files:
+                    create_params['tools'].append({'type': 'retrieval'})
+                    create_params['file_ids'] = list(map(lambda x: x['id'], files))
+
+                # Create the assistant using the uploaded file IDs if files exist
+                assistant = self.client.beta.assistants.create(**create_params)
+            print("***********************************************")
+
+    def create_assistants(self):
+        agents_path = os.path.join(
+            Path(__file__).absolute().parent, self.agents_path
+        )
+
+        # Check if the 'agents' folder is empty or doesn't exist
+        if (
+            not os.path.exists(agents_path)
+            or not os.path.isdir(agents_path)
+            or not os.listdir(agents_path)
+        ):
+            raise ValueError(f'The "{self.agents_path}" folder is missing, not a directory, or empty.')
+
+        self.get_existing_assistants()
+
+        # Iterate over each folder inside the 'agents' folder
+        for agent_name in os.listdir(agents_path):
+            self.create_assistant(agent_name)
+
+if __name__ == '__main__':
+    client = get_openai_client()
+    agent_builder = AgentBuilder(client=client)
+    agent_builder.create_assistants()