added Kani agents

src/agents.py

@@ -1,34 +1,16 @@
-from langchain import hub
-from langchain.agents import AgentExecutor, create_openai_functions_agent
-from langchain_openai import ChatOpenAI
+from kani import Kani
 
-from langchain.prompts import PromptTemplate
-from reasoning_tools import animal_tools, extract_vote
 
-# LLM Configuration for each role
-llm_parameters = {
-        "chameleon": {
-            'model': 'gpt-4-turbo-preview',
-            'temperature': 1
-        },
-        "herd": {
-            'model': 'gpt-3.5-turbo',
-            'temperature': 1
-        },
-        "judge": {
-            'model': 'gpt-3.5-turbo',
-            'temperature': 1
-        }
-}
+class LogMessagesKani(Kani):
+    def __init__(self, engine, log_filepath: str = None,  *args, **kwargs):
+        super().__init__(engine, *args, **kwargs)
+        self.log_filepath = log_filepath
 
-prompt = hub.pull("hwchase17/openai-functions-agent")
+    async def add_to_history(self, message, *args, **kwargs):
+        await super().add_to_history(message, *args, **kwargs)
 
-
-class PlayerAgent(AgentExecutor):
-
-    def __init__(self, role):
-        llm = ChatOpenAI(**llm_parameters[role])
-
-        agent = create_openai_functions_agent(llm, animal_tools, prompt)
-
-        super().__init__(agent=agent, tools=animal_tools, verbose=True, return_intermediate_steps=True)
+        # Logs Message to File
+        if self.log_filepath:
+            with open(self.log_filepath, "a") as log_file:
+                log_file.write(message.model_dump_json())
+                log_file.write("\n")

src/parser.py

@@ -2,10 +2,11 @@ from typing import Type
 import asyncio
 import json
 
-from kani import Kani
 from kani.engines.openai import OpenAIEngine
 from pydantic import BaseModel, ValidationError
 
+from agents import LogMessagesKani
+
 FORMAT_INSTRUCTIONS = """The output should be reformatted as a JSON instance that conforms to the JSON schema below.
 Here is the output schema:
 ```
@@ -24,7 +25,7 @@ Output:
 """
 
 
-class ParserKani(Kani):
+class ParserKani(LogMessagesKani):
     def __init__(self, engine, *args, **kwargs):
         super().__init__(engine, *args, **kwargs)
 

src/player.py

@@ -1,5 +1,10 @@
 import os
+import asyncio
+
 import openai
+from agents import LogMessagesKani
+from kani.engines.openai import OpenAIEngine
+
 
 # Using TGI Inference Endpoints from Hugging Face
 # api_type = "tgi"
@@ -15,40 +20,35 @@ else:
     model_name = "gpt-3.5-turbo"
     client = openai.Client()
 
+openai_engine = OpenAIEngine(model="gpt-3.5-turbo")
+
+
 class Player:
-    def __init__(self, name: str, controller: str, role: str):
+    def __init__(self, name: str, controller_type: str, role: str, log_filepath: str = None):
         self.name = name
-        self.controller = controller
+        self.controller = controller_type
+        if controller_type == "ai":
+            self.kani = LogMessagesKani(openai_engine, log_filepath=log_filepath)
+
         self.role = role
         self.messages = []
 
-    def collect_input(self, prompt: str) -> str:
-        """Store the input and output in the messages list. Return the output."""
-        self.messages.append({"role": "user", "content": prompt})
-        output = self.respond(prompt)
-        self.messages.append({"role": "assistant", "content": output})
+    async def respond_to(self, prompt: str) -> str:
+        """Makes the player respond to a prompt. Returns the response."""
+        # Generate a response from the controller
+        output = await self.__generate(prompt)
+
         return output
 
-    def respond(self, prompt: str) -> str:
+    async def __generate(self, prompt: str) -> str:
         if self.controller == "human":
             print(prompt)
             return input()
 
         elif self.controller == "ai":
-            chat_completion = client.chat.completions.create(
-                model=model_name,
-                messages=self.messages,
-                stream=False,
-            )
-
-            return chat_completion.choices[0].message.content
-
-
-    def add_message(self, message: str):
-        """Add a message to the messages list. No response required."""
-        self.messages.append({"role": "user", "content": message})
-
+            output = await self.kani.chat_round_str(prompt)
 
+            return output