Add application file

agent.py

@@ -0,0 +1,467 @@
+# Reference: https://python.langchain.com/en/latest/use_cases/agent_simulations
+
+import re
+from datetime import datetime
+from typing import List, Optional, Tuple
+
+from langchain import LLMChain
+from langchain.base_language import BaseLanguageModel
+from langchain.prompts import PromptTemplate
+from langchain.retrievers import TimeWeightedVectorStoreRetriever
+from langchain.schema import Document
+from pydantic import BaseModel, Field
+from termcolor import colored
+import util
+import time
+
+class SuspicionAgent(BaseModel):
+    """A character with memory and innate characteristics."""
+
+    name: str
+    game_name: str
+    age: int
+    observation_rule: str
+    """The traits of the character you wish not to change."""
+    status: str
+    """Current activities of the character."""
+    llm: BaseLanguageModel
+
+    """The retriever to fetch related memories."""
+    verbose: bool = False
+
+    reflection_threshold: Optional[float] = None
+    """When the total 'importance' of memories exceeds the above threshold, stop to reflect."""
+
+    current_plan: List[str] = []
+    belief: str = ""
+    pattern: str = ""
+    long_belief: str = ""
+    counter_belief: str = ""
+    plan: str = ""
+    high_plan: str = ""
+    """The current plan of the agent."""
+
+    memory: List = ['']
+    summary: str = ""  #: :meta private:
+    summary_refresh_seconds: int = 3600  #: :meta private:
+    last_refreshed: datetime = Field(default_factory=datetime.now)  #: :meta private:
+
+    memory_importance: float = 0.0  #: :meta private:
+    max_tokens_limit: int = 1200  #: :meta private:
+    read_observation: str = ""  #: :meta private:
+
+    rule: str = ""  #: :meta private:
+    class Config:
+        """Configuration for this pydantic object."""
+
+        arbitrary_types_allowed = True
+
+
+        
+
+    
+    
+    def add_long_memory(self, memory_content: str) -> List[str]:
+        """Add an observation or memory to the agent's memory."""
+        self.memory.append(memory_content)
+        return  self.memory
+
+
+ 
+
+    def planning_module(self, observation: str,  recipient_name:str, previous_conversation: List[str] =None, belief: str =None, valid_action_list: List[str] = None, short_memory_summary:str = "",pattern:str = "",last_plan:str = "", mode: str = "second_tom") -> str:
+        """Make Plans and Evaluate Plans."""
+        """Combining these two modules together to save costs"""
+
+        if mode == 'second_tom':
+            prompt = PromptTemplate.from_template(
+                "You are the objective player behind a NPC character called {initiator_name}, and you are playing the board game {game_name} with {recipient_name}.\n"
+            + " The game rule is: {rule} \n"
+             +'{pattern}\n'
+              + " Your observation about the game status now is: {observation}\n"
+            +'{belief}\n'
+            + " Understanding all given information, can you do following things:"
+            + " Make Reasonable Plans: Please plan several strategies according to actions {valid_action_list} you can play now to win the finally whole {game_name} games step by step. Note that you can say something or keep silent to confuse your opponent. " 
+                 + " Potential {recipient_name}'s actions (if release) and Estimate Winning/Lose/Draw Rate for Each Plan: From the perspective of {recipient_name} , please infer what the action {recipient_name} with probability (normalize to number 100% in total) would do when {recipient_name} holds different cards and then calculate the winning/lose/draw rates when {recipient_name} holds different cards step by step. At last, please calculate the overall winning/lose/draw rates for each plan step by step considering  {recipient_name}'s behaviour pattern. Output in a tree-structure: "        
+                + "Output: Plan 1:  If I execute plan1.  "
+                          "The winning/lose/draw rates when {recipient_name} holds card1: Based on {recipient_name}'s behaviour pattern, In the xx round, because {recipient_name} holds card1  (probability) and the combination with current public card (if release)  (based on my belief on {recipient_name}), and if he sees my action, {recipient_name} will do action1 (probability) ( I actually hold card and the public card (if reveal) is , he holds card1 and the public card (if reveal), considering Single Game Win/Draw/Lose Rule, please infer I will win/draw/lose  step by step ), action2 (probability) (considering Single Game Win/Draw/Lose Rule, please infer I will win/draw/lose step by step  ),.. (normalize to number 100% in total); \n   Overall (winning rate for his card1) is (probability = his card probability * win action probability), (lose rate for his card2) is (probability= his card probability * lose action probability), (draw rate for his card2) is (probability = his card probability * draw action probability)  "  
+                          "The winning/lose/draw rates when {recipient_name} holds card2: Based on {recipient_name}'s behaviour pattern, In the xx round, because {recipient_name} holds card2  (probability) and the combination with current public card (if release)  (based on my belief on {recipient_name}) ,  and if he sees my action, he will do action1 (probability) (I actually hold card and the public card (if reveal) is , he holds card1 and the public card (if reveal), considering Single Game Win/Draw/Lose Rule, please infer I will win/draw/lose  step by step ).. action2 (probability) (normalize to number 100% in total) (considering Single Game Win/Draw/Lose Rule, please infer I will win/draw/lose step by step ),.. ;..... continue ....\n Overall (winning rate for his card2) is (probability = his card probability * win action probability), (lose rate for his card2) is (probability= his card probability * lose action probability), (draw rate for his card2) is (probability = his card probability * draw action probability) "  
+                          "...\n"
+                          "Plan1 overall {initiator_name}'s Winning/Lose/Draw rates : the Winning rate (probability) for plan 1 is (winning rate for his card1) + (winning rate for his card2) + .. ; Lose rate (probability) for plan 1 : (lose rate for his card1) + (lose rate for his card2) + .. ; Draw Rate (probability) for plan 1  : (draw rate for his card1) + (draw rate for his card2) + ... ;  (normalize to number 100% in total) for plan1 \n"
+                "Plan 2: If I execute plan2, The winning/lose/draw rates when {recipient_name} holds card1: Based on {recipient_name}'s behaviour pattern, In the xx round, if {recipient_name} holds card1  (probability)  and the combination with current public card (if release),  .. (format is similar with before ) ... continue .."
+                "Plan 3: .. Coninue ... "
+                + " The number of payoffs for each plan: Understanding your current observation,  each new plans, please infer the number of wininng/lose payoffs for each plan step by step, Output: Plan1: After the action, All chips  in the pot:  If win, the winning payoff would be (Calculated by Winning Payoff Rules step by step) :  After the action,  All chips in the pot:  If lose , the lose payoff would be:  (Calculated by Lose Payoff Rules step by step). Plan2:  After the action, All chips in the pot:  If win, the winning chips would be (Calculated by Winning Payoff Rules step by step):  After the action, All chips in the pot:  If lose , the lose chips would be:  (Calculated by Lose Payoff Rules step by step). If the number of my chips in pots have no change, please directly output them. \n"
+                + " Estimate Expected Chips Gain for Each Plan: Understanding all the information and Estimate Winning/Lose/Draw Rate for Each Plan, please estimate the overall average Expected Chips Gain for each plan/strategy in the current game by calculating winning rate * (Winning Payoff Rule in the game rule) - lose rate * (Lose Payoff Rule in the game rule) step by step"
+                + " Plan Selection: Please output the rank of estimated expected chips gains for every plan objectively step by step, and select the plan/strategy with the highest estimated expected chips gain considering both the strategy improvement. \n "
+            )
+       
+        elif mode == 'first_tom':
+            prompt = PromptTemplate.from_template(
+                "You are the player behind a NPC character called {initiator_name}, and you are playing the board game {game_name} with {recipient_name}.\n"
+            + " The game rule is: {rule} \n"
+            + " {pattern} \n"
+            + " Your observation about the game status now is: {observation}\n"
+            + ' {belief}\n'
+            + " Understanding all given information, can you do following things:"
+            + " Make Reasonable Plans: Please plan several strategies according to actions {valid_action_list} you can play now to win the finally whole {game_name} games step by step. Note that you can say something or keep silent to confuse your opponent." 
+            + " Potential {recipient_name}'s actions and Estimate Winning/Lose/Draw Rate: From the perspective of {recipient_name}, please infer what the action {recipient_name} with probability (normalize to number 100% in total) would do when {recipient_name} holds different cards, and then calculate the winning/lose/draw rates when {recipient_name} holds different cards step by step. Output in a tree-structure: "        
+                + "Output: Based on {recipient_name}'s behaviour pattern and Analysis on {recipient_name}'s cards, "
+                "Winning/lose/draw rates when {recipient_name} holds card1 in the xx round,: if {recipient_name} holds card1  (probability) (based on my belief on {recipient_name}) with the public card  (if release), {recipient_name} will do action1 (probability) (infer I will win/draw/lose step by step (considering Single Game Win/Draw/Lose Rule and my factual card analysis with public card (if release), his card analysis with public card (if release) step by step ), action2 (probability) (infer I will win/draw/lose step by step  ),.. (normalize to number 100% in total);    Overall (winning rate for his card1) is (probability = his card probability * win action probability), (lose rate for his card2) is (probability= his card probability * lose action probability), (draw rate for his card2) is (probability = his card probability * draw action probability)  "  
+                          "The winning/lose/draw rates when {recipient_name} holds card2 in the xx round,: If {recipient_name} holds card2  (probability) (based on my belief on {recipient_name}) with the public card  (if release),  he will do action1 (probability) (infer I will win/draw/lose (considering Single Game Win/Draw/Lose Rule and my factual card analysis with current public card (if release), his card analysis with current public card (if release)) step by step ).. action2 (probability) (normalize to number 100% in total) (infer I will win/draw/lose step by step ),..  based on  {recipient_name}'s behaviour pattern;..... continue .... Overall (winning rate for his card2) is (probability = his card probability * win action probability), (lose rate for his card2) is (probability= his card probability * lose action probability), (draw rate for his card2) is (probability = his card probability * draw action probability) "  
+                          "..."
+                          "Overall {initiator_name}'s Winning/Lose/Draw rates : Based on the above analysis,  the Winning rate (probability) is (winning rate for his card1) + (winning rate for his card2) + .. ; Lose rate (probability): (lose rate for his card1) + (lose rate for his card2) + .. ; Draw Rate (probability): (draw rate for his card1) + (draw rate for his card2) + ... ;  (normalize to number 100% in total). \n"         
+            + " Potential believes about the number of winning and lose payoffs for each plan: Understanding the game rule, your current observation, previous actions summarization, each new plans, Winning Payoff Rule,  Lose Payoff Rule, please infer your several believes about  the number of chips in pots for each plan step by step, Output: Plan1: Chips in the pot:  If win, the winning payoff would be (Calculated by Winning Payoff Rules in the game rule) :  After the action, If lose , the lose payoff would be: . Plan2:  Chips in the pot:  If win, the winning chips would be (Calculated by Winning Payoff Rules in the game rule):  After the action, If lose , the lose chips would be: . If the number of my chips in pots have no change, please directly output them. "
+            + " Estimate Expected Chips Gain for Each Plan: Understanding the game rule, plans,  and your knowledge about the {game_name}, please estimate the overall average Expected Chips Gain for each plan/strategy in the current game by calculating winning rate * (Winning Payoff Rule in the game rule) - lose rate * (Lose Payoff Rule in the game rule)., explain what is the results if you do not select the plan, and explain why is this final  Expected  Chips Gain reasonablely step by step? "
+            + " Plan Selection: Please output the rank of estimated expected chips gains for every plan objectively step by step, and select the plan/strategy with the highest estimated expected chips gain considering both the strategy improvement. \n\n "
+                )
+        else:
+             prompt = PromptTemplate.from_template(
+                "You are the player behind a NPC character called {initiator_name}, and you are playing the board game {game_name} with {recipient_name}.\n"
+            + " The game rule is: {rule} \n"
+            + "  {pattern} \n"
+            + " Your observation about the game status now is: {observation}\n"
+            + " Understanding all given information, can you do following things:"
+            + " Make Reasonable Plans: Please plan several strategies according to actions {valid_action_list} you can play now to win the finally whole {game_name} games step by step. Note that you can say something or keep silent to confuse your opponent." 
+               + " Estimate Winning/Lose/Draw Rate for Each Plan: Understanding the given information, and your knowledge about the {game_name}, please estimate the success rate of each step of each plan step by step and the overall average winning/lose/draw rate  (normalize to number 100% in total) of each plan/strategy for the current game  step by step following the templete: If I do plan1, because I hold card, the public information (if release) and Single Game Win/Draw/Lose Rule, I will win or Lose or draw (probability);  ... continue  .... Overall win/draw/lose rate: Based on the analysis, I can do the weighted average step by step to get that the overall weighted average winning rate is (probability), average lose rate is (probability), draw rate is (probability) (normalize to number 100% in total)\n "
+               + " Potential believes about the number of winning and lose payoffs for each plan: Understanding the game rule, your current observation, previous actions summarization, each new plans, Winning Payoff Rule,  Lose Payoff Rule, please infer your several believes about  the number of chips in pots for each plan step by step, Output: Plan1: Chips in the pot:  If win, the winning payoff would be (Calculated by Winning Payoff Rules in the game rule) :  After the action,  Chips in the pot:  If lose , the lose payoff would be: . Plan2:  Chips in the pot:  If win, the winning chips would be (Calculated by Winning Payoff Rules in the game rule):  After the action, Chips in the pot:   If lose , the lose chips would be: . If the number of my chips in pots have no change, please directly output them. "
+               +" Estimate Expected Chips Gain for Each Plan: Understanding the game rule, plans,  and your knowledge about the {game_name}, please estimate the overall average Expected Chips Gain for each plan/strategy in the current game by calculating winning rate * (Winning Payoff Rule in the game rule) - lose rate * (Lose Payoff Rule in the game rule)., explain what is the results if you do not select the plan, and explain why is this final  Expected  Chips Gain reasonablely step by step? "
+            + " Plan Selection: Please output the rank of estimated expected chips gains for every plan objectively step by step, and select the plan/strategy with the highest estimated expected chips gain considering both the strategy improvement. \n\n "
+                )
+
+        agent_summary_description = short_memory_summary
+       
+        belief = self.belief if belief is None else belief
+      
+        kwargs = dict(
+            
+            recent_observations=agent_summary_description,
+            last_plan=last_plan,
+            belief=belief,
+            initiator_name=self.name,
+            pattern=pattern,
+            recipient_name=recipient_name,
+            observation=observation,
+            rule=self.rule,
+            game_name=self.game_name,
+            valid_action_list=valid_action_list
+        )
+
+
+        plan_prediction_chain = LLMChain(llm=self.llm, prompt=prompt)
+        self.plan = plan_prediction_chain.run(**kwargs)
+        self.plan = self.plan.strip()
+
+        return self.plan.strip()
+
+       
+    
+    def get_belief(self, observation: str, recipient_name: str,short_memory_summary:str,pattern:str = "",mode: str = "second_tom") -> str:
+        """React to get a belief."""
+        if mode == 'second_tom':
+            prompt = PromptTemplate.from_template(
+                "You are the player behind a NPC character called {agent_name}, and you are playing the board game {game_name} with {recipient_name}. \n"
+                + " The game rule is: {rule} \n"
+                + " Your estimated judgement about the behaviour pattern of {recipient_name} and improved strategy is: {pattern} \n"
+                + " Your observation now is: {observation}\n"
+                + " Your current game progress summarization including actions and conversations with {recipient_name} is: {recent_observations}\n"
+                + " Understanding the game rule, the cards you have, your observation,  progress summarization in the current game, the estimated behaviour pattern of {recipient_name}, the potential guess pattern of {recipient_name} on you, and your knowledge about the {game_name}, can you do following things? "
+                + " Analysis on my Cards: Understanding all given information and your knowledge about the {game_name}, please analysis what is your best combination and advantages of your cards in the current round step by step." 
+                + " Belief on {recipient_name}'s cards: Understanding all given information, please infer the probabilities about the cards of {recipient_name}  (normalize to number 100% in total) objectively step by step." 
+                "Output: {recipient_name}  saw my history actions (or not) and then did action1 (probability) in the 1st round , ... continue..... Before this round, {recipient_name}  say my history actions (or not) and  did action1 (probability), because {recipient_name}'s behaviour pattern and the match with the public card (if release), {recipient_name} tends to have card1 (probability), card2 (probability) ..continue.. (normalize to number 100% in total)."
+                + " Analysis on {recipient_name}'s Cards: Understanding all given information and your knowledge about the {game_name}, please analysis what is {recipient_name}'s best combination and advantages of {recipient_name}'s cards in the current round  step by step." 
+                + " Potential {recipient_name}'s current believes about your cards: Understanding all given information and your knowledge about the {game_name}, If you were {recipient_name} (he can only observe my actions but cannot see my cards), please infer the {recipient_name}'s  believes about your cards with probability (normalize to number 100% in total) step by step. Output: {agent_name} did action1 (probability) (after I did action or not) in the 1st round, , ... continue...  {agent_name} did action1 (probability) (after I did action or not)  in the current round,, from the perspective of {recipient_name}, {agent_name} tends to have card1 (probability), card2 (probability) ... (normalize to number 100% in total) ."
+                )
+        elif mode == 'first_tom':
+            prompt = PromptTemplate.from_template(
+                "You are the player behind a NPC character called {agent_name}, and you are playing the board game {game_name} with {recipient_name}. \n"
+                + " The game rule is: {rule} \n"
+                + " Your estimated judgement about the behaviour pattern of {recipient_name} and improved strategy is: {pattern} \n"
+                + " Your observation now is: {observation}\n"
+                + " Your current game progress summarization including actions and conversations with {recipient_name} is: {recent_observations}\n"
+                + " Understanding the game rule, the cards you have, your observation,  progress summarization in the current game, the estimated behaviour pattern of {recipient_name} on you, and your knowledge about the {game_name}, can you do following things? "
+                + " Analysis on my Cards: Understanding all given information, please analysis what is your best combination and advantages of your cards  in the current round  step by step." 
+                + " Belief on {recipient_name}'s cards: Understanding all given information, please infer your the probabilities about the cards of {recipient_name}  (normalize to number 100% total)  step by step. Templete: In the 1st round, {recipient_name} did action1 (probability),  ... continue... In the current round, {recipient_name} did action1 (probability), because {recipient_name}'s behaviour pattern and the match with the current public card (if release), he tends to have card1 (probability), card2 (probability) (normalize to number 100% in total). "
+            + " Analysis on {recipient_name}'s Cards: Understanding all given information, please analysis what is {recipient_name}'s best combination and advantages of {recipient_name}'s cards  in the current round  step by step." 
+                
+            )
+        agent_summary_description = short_memory_summary
+
+        kwargs = dict(
+            agent_summary_description=agent_summary_description,
+            recent_observations=agent_summary_description,
+            agent_name=self.name,
+            pattern= pattern,
+            recipient_name=recipient_name,
+            observation=observation,
+            game_name=self.game_name,
+            rule=self.rule
+
+        )
+        print(recipient_name)
+        
+        belief_prediction_chain = LLMChain(llm=self.llm, prompt=prompt)
+        self.belief = belief_prediction_chain.run(**kwargs)
+        self.belief = self.belief.strip()
+        return self.belief.strip()
+
+    
+    def get_pattern(self, recipient_name: str,game_pattern: str='', last_k:int=20,short_summarization:str='',mode:str='second_tom') -> str:
+        """React to get a belief."""
+       
+        if mode == 'second_tom':
+            prompt = PromptTemplate.from_template(
+                "You are the objective player behind a NPC character called {agent_name}, and you are playing {game_name} with {recipient_name}. \n"
+                + " The game rule is: {rule} \n"
+                + " Your previous game memory including observations, actions and conversations with {recipient_name} is: {long_memory}\n"
+                + "  {recipient_name}'s game pattern: Understanding all given information and your understanding about the {game_name}, please infer and estimate as many as possible reasonable {recipient_name}'s game behaviour pattern/preferences for each card he holds and each round with probability (normalize to number 100\% in total for each pattern item) and please also infer advantages of his card, and analysis how the {recipient_name}'s behaviour pattern/preferences are influenced by my actions when he holds different cards step by step. Output  as a tree-structure    " 
+                + "Output: When {recipient_name} holds card1 and the combination of public card (if release):  if {recipient_name}  is the first to act, he would like to do action1 (probabilities), action2 (probabilities) ... continue ..    If {recipient_name} sees the action1/action2/action3 of the opponent or not, he would like to do action1 (probabilities), action2 (probabilities) ... continue ...  (normalize to number 100% in total), if {recipient_name} sees the action2 of the opponent  or not,  ... continue ..(more patterns with different actions)..  in the 1st round, ;  If {recipient_name} sees the action1 of the opponent  or not,  he would like to do action1 (probabilities), action2 (probabilities) ... continue... (normalize to number 100% in total), ...  continue ..(more patterns)..In the 2nd round,;"
+                 "When {recipient_name} holds card2 and combination of public card (if release): if {recipient_name}  is the first to act, he would like to do action1 (probabilities), action2 (probabilities) ... continue .. If {recipient_name} sees the action1 of the opponent  or not, he would like to do action1 (probabilities), action2 (probabilities) .. continue ... (normalize to number 100% in total)...in the 1st round,; .. continue ..(more patterns  with different actions).in the 2nd round .. "
+                 " (more patterns with different cards).. continue.."
+                + "  {recipient_name}'s guess on my game pattern: Understanding all given information, please infer several reasonable believes about my game pattern/preference when holding different cards from the perspective of {recipient_name} (please  consider the advantages of the card, actions and the the match with the public card (if release)) for every round of the game in detail as a tree-structure output step by step"
+               + "Output: In the 1st round, When name holds card1 with public card (if release), he would like to do (probabilities), action2 (probabilities)  (normalize to number 100% in total) o ... continue .. and then do action ...;"
+                 "When name holds card2 with public card (if release), ... "
+                 " .. continue.."
+                + " Strategy Improvement: Understanding the above information, think about what strategies I can adopt to exploit the game pattern of {recipient_name} and {recipient_name}'s guess on my game pattern for winning {recipient_name} in the whole game step by step.  (Note that you cannot observe the cards of the opponent during the game, but you can observe his actions). Output as a tree-structure:"
+                "When I hold card and the public card (if release), and see the action of the opponent, I would like to do action1; ... "
+            )
+        elif mode == 'first_tom':
+            prompt = PromptTemplate.from_template(
+                "You are the player behind a NPC character called {agent_name}, and you are playing the board game {game_name} with {recipient_name}. \n"
+                + " The game rule is: {rule} \n"
+                + " Your previous game memory including observations, actions and conversations with {recipient_name} is: {long_memory}\n"
+                + " Please understand the game rule, previous all game history and your knowledge about the {game_name}, can you do following things for future games? "
+                + "  {recipient_name}'s game pattern: Understanding all given information, please infer all possible reasonable {recipient_name}'s game pattern/preferences for each card he holds and each round with probability (normalize to number 100\% in total for each pattern item) for every round of the game as a tree-structure output step by step  " 
+                + "Output: In the 1st round, when name holds card1 and the public card (if release), he would like to do action (probabilities); when name holds card2 and the public card (if release), he would like to do action (probabilities), ... continue.. In the 2nd round,  when name holds card1 and the public card (if release), .(similar with before).. continue. "
+               + " Number of chips reason: Think about why you can have these chips in all previous games step by step. "
+                + " Reflex: Reflex which your actions are right or wrong in previous games to win or Lose conrete chips step by step  (Note that you cannot observe the cards of the opponent during the game, but you can observe his actions) "
+                + " Strategy Improvement: Understanding the above information, think about what strategies I can adopt to exploit the game pattern of {recipient_name} for winning {recipient_name} in the whole game step by step.  (Note that you cannot observe the cards of the opponent during the game, but you can observe his actions). Output as a tree-structure:"
+                )
+        else:
+            prompt = PromptTemplate.from_template(
+                "You are the player behind a NPC character called {agent_name}, and you are playing the board game {game_name} with {recipient_name}. \n"
+                + " The game rule is: {rule} \n"
+                + " Your previous game memory including observations, actions and conversations with {recipient_name} is: {long_memory}\n"
+                + " Please understand the game rule, previous all game history and your knowledge about the {game_name}, can you do following things for future games? "
+                + " Number of chips reason: Think about why you can have these chips in all previous games step by step. "
+                + " Reflex: Reflex which your actions are right or wrong in previous games to win or Lose conrete chips step by step. (Note that you cannot observe the cards of the opponent during the game, but you can observe his actions) "
+                + " Strategy Improvement: Understanding the above information, think about what strategies I need to adopt to win {recipient_name} for the whole game step by step.  (Note that you cannot observe the cards of the opponent during the game, but you can observe his actions). Output as a tree-structure:"
+            )
+        reflection_chain = LLMChain(llm=self.llm, prompt=prompt, verbose=self.verbose)
+        long_memory = self.memory[-last_k:]
+        long_memory_str = "\n\n".join([o for o in long_memory])
+        
+        kwargs = dict(
+            long_memory=long_memory_str,
+            game_pattern=game_pattern,
+            agent_name=self.name,
+            recipient_name=recipient_name,
+            game_name=self.game_name,
+            rule=self.rule
+
+        )
+        # print(kwargs)
+
+        self.long_belief = reflection_chain.run(**kwargs)
+        self.long_belief = self.long_belief.strip()
+        return self.long_belief.strip()
+
+
+
+    def get_summarization(self, recipient_name: str,game_memory: str, opponent_name:str) -> str:
+        """Get a long memory summarization to save costs."""
+        prompt = PromptTemplate.from_template(
+            "You are the player behind a NPC character called {agent_name}, and you are playing the board game {game_name} with {recipient_name}. \n"
+            + " The game rule is: {rule} \n"
+            + " The observation conversion rules are: {observation_rule}\n"
+            + " One game memory including observations, actions and conversations with {recipient_name} is: {long_memory}\n"
+            + " Understanding the game rule, observation conversion rules and game history and your knowledge about the {game_name}, can you do following things:"
+            + " History summarization: summary the game history with action, observation, and results information? using the templete, and respond shortly: In the first round of first game, name holds card1 does action .... continue ..." 
+            + "{opponent_name}'s card reasoning: If the card of {opponent_name} is not available, because {agent_name}'s  card is xx and public card (if release) is xxx, and {opponent_name} behaviours are xx, the current game result is xx,  please  infer {opponent_name}'s card with probability (100% in total) with your understanding about the above all information confidently step by step. \n"
+                )        
+        reflection_chain = LLMChain(llm=self.llm, prompt=prompt, verbose=self.verbose)
+        kwargs = dict(
+            observation_rule=self.observation_rule,
+            long_memory=game_memory,
+            agent_name=self.name,
+            recipient_name=recipient_name,
+            opponent_name=opponent_name,
+            # observation=observation,
+            game_name=self.game_name,
+            rule=self.rule
+
+        )
+        # print(kwargs)
+
+        self.long_belief = reflection_chain.run(**kwargs)
+        self.long_belief = self.long_belief.strip()
+        return self.long_belief.strip()
+
+
+    def get_short_memory_summary(self, observation: str, recipient_name: str,short_memory_summary:str) -> str:
+        """React to get a belief."""
+        prompt = PromptTemplate.from_template(
+            "You are the player behind a NPC character called {agent_name}, and you are playing the board game {game_name} with {recipient_name}. \n"
+            + " The game rule is: {rule} \n"
+            + " Your current observation is: {observation}\n"
+            + " The current game history including previous action, observations and conversation is: {agent_summary_description}\n"
+            + " Based on the game rule, your observation and your knowledge about the {game_name}, please summarize the current history. Output as a tree-structure, and respond shortly: "
+            + " In the first round, name does action, and say xxx .... continue ..." 
+        )
+
+        agent_summary_description = short_memory_summary
+    
+        kwargs = dict(
+            agent_summary_description=agent_summary_description,
+            recent_observations=agent_summary_description,
+            agent_name=self.name,
+            recipient_name=recipient_name,
+            observation=observation,
+            game_name=self.game_name,
+            rule=self.rule
+
+        )
+
+        belief_prediction_chain = LLMChain(llm=self.llm, prompt=prompt)
+        self.belief = belief_prediction_chain.run(**kwargs)
+        self.belief = self.belief.strip()
+        return self.belief.strip()
+
+
+
+    def convert_obs(self, observation: str, recipient_name: str, user_index: str, valid_action_list:str) ->  str:
+        """React to get a belief."""
+        prompt = PromptTemplate.from_template(
+            "You are the player behind a NPC character called {agent_name} with player index {user_index}, and you are playing the board game {game_name} with {recipient_name}. \n"
+            + " The game rule is: {rule} \n"
+            + " Your observation now is: {observation}\n"
+            + " You will receive a valid action list you can perform in this turn \n"
+            + " Your valid action list is: {valid_action_list}\n"
+            + " The observation conversion rules are: {observation_rule}\n"
+            + " Please convert {observation} and {valid_action_list} to the readable text based on the observation conversion rules and your knowledge about the {game_name} (respond shortly).\n\n"
+        )
+        kwargs = dict(
+            user_index=user_index,
+            agent_name=self.name,
+            rule=self.rule,
+            recipient_name=recipient_name,
+            observation=observation,
+            valid_action_list=valid_action_list,
+            game_name=self.game_name,
+            observation_rule=self.observation_rule
+        )
+        obs_prediction_chain = LLMChain(llm=self.llm, prompt=prompt)
+        self.read_observation = obs_prediction_chain.run(**kwargs)
+        self.read_observation = self.read_observation.strip()
+        return self.read_observation
+
+
+
+    def action_decision(self, observation: str, valid_action_list: List[str], promp_head: str, act: str = None,short_memory_summary:str="") -> Tuple[str,str]:
+        """React to a given observation."""
+        """React to a given observation."""
+        prompt = PromptTemplate.from_template(
+            promp_head
+            + "\nYour plan is: {plan}"
+            + "\n Based on the plan, please select the next action from the available action list: {valid_action_list} (Just one word) and say something to the opponent player to bluff or confuse him or keep silent to finally win the whole game and reduce the risk of your action (respond sentence only). Please respond them and split them by |"
+            + "\n\n"
+        )
+
+        agent_summary_description = short_memory_summary
+
+        kwargs = dict(
+            agent_summary_description= agent_summary_description,
+            # current_time=current_time_str,
+            # relevant_memories=relevant_memories_str,
+            agent_name= self.name,
+            game_name=self.game_name,
+            observation= observation,
+            agent_status= self.status,
+            valid_action_list = valid_action_list,
+            plan = self.plan,
+            belief = self.belief,
+            act = act
+        )
+        action_prediction_chain = LLMChain(llm=self.llm, prompt=prompt)
+
+        result = action_prediction_chain.run(**kwargs)
+        if "|" in result:
+            result,result_comm = result.split("|",1)
+        else:
+            result_comm = ""
+        return result.strip(),result_comm.strip()
+
+    def make_act(self, observation: str,opponent_name: str, player_index:int,valid_action_list: List, verbose_print:bool,game_idx:int,round:int,bot_short_memory:List, bot_long_memory:List, console,log_file_name='', mode='second_tom') -> Tuple[bool, str]:
+        readable_text_amy_obs = self.convert_obs(observation, opponent_name, player_index, valid_action_list)
+        if  verbose_print:
+            util.get_logging(logger_name=log_file_name + '_obs',
+                        content={str(game_idx + 1) + "_" + str(round): {"raw_obs": observation,
+                                                                        "readable_text_obs": readable_text_amy_obs}})
+            console.print('readable_text_obs: ', style="red")
+            print(readable_text_amy_obs)
+        time.sleep(0)
+        if len(bot_short_memory[player_index]) == 1:
+            short_memory_summary = f'{game_idx+1}th Game Start \n'+readable_text_amy_obs
+        else:
+            short_memory_summary = self.get_short_memory_summary(observation=readable_text_amy_obs, recipient_name=opponent_name,short_memory_summary='\n'.join(bot_short_memory[player_index]))
+
+        if log_file_name is not None:
+            util.get_logging(logger_name=log_file_name + '_short_memory',
+                        content={str(game_idx + 1) + "_" + str(round): {
+                            "raw_short_memory": '\n'.join(bot_short_memory[player_index]),
+                            "short_memory_summary": short_memory_summary}})
+        if verbose_print:
+            console.print('short_memory_summary: ', style="yellow")
+            print(short_memory_summary)
+
+        time.sleep(0)
+        if  round <= 1:
+                self.pattern = self.get_pattern(opponent_name,'',short_summarization=short_memory_summary,mode=mode)
+                if log_file_name is not None:
+                    util.get_logging(logger_name=log_file_name + '_pattern_model',
+                                content={str(game_idx + 1) + "_" + str(round): self.pattern})
+                console.print('pattern: ', style="blue")
+                print(self.pattern)
+
+        time.sleep(0)
+        print(opponent_name)
+
+        if mode == 'second_tom' or mode == 'first_tom':
+            belief = self.get_belief(readable_text_amy_obs,opponent_name,short_memory_summary=short_memory_summary,pattern=self.pattern,mode=mode)
+            if verbose_print:
+                console.print(self.name + " belief: " , style="deep_pink3")
+                print(self.name + " belief: " + str(belief))
+                util.get_logging(logger_name=log_file_name + '_belief',
+                            content={str(game_idx + 1) + "_" + str(round): {
+                                "belief": str(belief)}})
+        else:
+            belief = ''
+
+        time.sleep(0)
+        plan = self.planning_module(readable_text_amy_obs,opponent_name, belief=belief,valid_action_list=valid_action_list,short_memory_summary=short_memory_summary,pattern=self.pattern,last_plan='', mode=mode)
+        if  verbose_print:
+            console.print(self.name + " plan: " , style="orchid")
+            print(self.name + " plan: " + str(plan))
+            util.get_logging(logger_name=log_file_name + '_plan',
+                        content={str(game_idx + 1) + "_" + str(round): {
+                            "plan": str(plan)}})
+        time.sleep(0)
+        promp_head = ''
+        act, comm = self.action_decision(readable_text_amy_obs, valid_action_list, promp_head,short_memory_summary=short_memory_summary)
+        if log_file_name is not None:
+            util.get_logging(logger_name= log_file_name + '_act',
+                        content={str(game_idx + 1) + "_" + str(round): {
+                            "act": str(act), "talk_sentence": str(comm)}})
+            
+        while act not in valid_action_list:
+            print('Action + ', str(act), ' is not a valid action in valid_action_list, please try again.\n')
+            promp_head += 'Action {act} is not a valid action in {valid_action_list}, please try again.\n'
+            act, comm = self.action_decision( readable_text_amy_obs, valid_action_list, promp_head,act)
+        print(self.name + " act: " + str(act))
+        print(comm)
+
+        bot_short_memory[player_index].append(f"{self.name} have the observation {readable_text_amy_obs}, try to take action: {act} and say {comm} to {opponent_name}")
+        bot_short_memory[((player_index + 1)%2)].append(f"{self.name} try to take action: {act} and say {comm} to {opponent_name}")
+
+        bot_long_memory[player_index].append(
+            f"{self.name} have the observation {observation}, try to take action: {act} and say {comm} to {opponent_name}")
+        return act,comm,bot_short_memory,bot_long_memory

app.py

@@ -0,0 +1,468 @@
+import gradio as gr
+import requests
+
+import json
+import os
+from pathlib import Path
+
+import inquirer
+import typer
+from rich.console import Console
+from rich.prompt import IntPrompt, Prompt, Confirm
+import argparse
+import logging
+
+import util
+from model import get_all_embeddings, get_all_llms
+from setting import Settings, get_all_model_settings, load_model_setting
+# import Settings, get_all_model_settings, load_model_setting
+from model import agi_init
+import gym
+from retriever import (
+    create_new_memory_retriever,
+)
+import gym_coup
+import random
+from rlcard.utils import set_seed
+import rlcard
+from rlcard import models
+from rlcard.models import leducholdem_rule_models
+
+
+#Inferenec function
+def predict(openai_gpt4_key, game_selection, action, inputs, top_p, temperature, chat_counter, dialogue_chatbot=[], system_chatbot=[], history=[]):  
+
+    verified, settings, env, ctx = history['verified'], history['settings'], history['env'], history['ctx']
+    bot_long_memory, bot_short_memory = history['bot_long_memory'], history['bot_short_memory']
+    agents_num, chips, user_index, game_idx, mode = history['agents_num'], history['chips'], history['user_index'], history['game_idx'], history['mode']
+
+    status_message = ''
+    valid_actions = gr.Dropdown.update(choices=[], value=None)
+
+    if env is None: #settings.model.llm.openai_api_key is None:
+        if not verified:
+            res = util.verify_openai_token(openai_gpt4_key)
+            if res != "OK":
+                return system_chatbot, dialogue_chatbot, valid_actions, history, chat_counter, res
+            history['verified'] = True
+
+        if game_selection == '' or game_selection is None:
+            return system_chatbot, dialogue_chatbot, valid_actions, history, chat_counter, "Please select a game."
+
+        settings = Settings()
+        settings.model = load_model_setting("openai-gpt-4-0613")
+
+        #settings.model.llm.openai_api_key = None
+        #settings.model.embedding.openai_api_key = None
+
+        settings.model.llm.openai_api_key = openai_gpt4_key
+        settings.model.embedding.openai_api_key = openai_gpt4_key
+        res = util.verify_model_initialization(settings)
+
+        if res != "OK":
+            return system_chatbot, dialogue_chatbot, valid_actions, history, chat_counter, res
+        else:
+            # read agents configs
+            agent1_file = 'person_config/Persuader.json'
+            agent1_config = util.load_json(Path(agent1_file))
+            agent1_config["path"] = agent1_file
+
+            agent2_file = 'person_config/GoodGuy.json'
+            agent2_config = util.load_json(Path(agent2_file))
+            agent2_config["path"] = agent2_file
+   
+            agent_configs = [agent1_config, agent2_config]
+            agent_names = [agent1_config["name"], agent2_config["name"]]
+            if game_selection == 'coup':
+                game_config_file = 'game_config/coup.json'
+            elif game_selection == 'leduc-holdem':
+                game_config_file = 'game_config/leduc_limit.json'
+            elif game_selection == 'limit-holdem':
+                game_config_file = 'game_config/limit_holdem.json'
+            
+            game_config = util.load_json(Path(game_config_file))
+            game_config["path"] = game_config_file
+                    
+            user_index = 1
+            console = Console()
+            ctx = agi_init(agent_configs, game_config, console, settings, user_index)
+            
+            os.environ["OPENAI_API_KEY"] = openai_gpt4_key
+            print(game_selection)
+            if game_selection != 'coup':
+                env = rlcard.make(game_selection)
+            else:
+                env = gym.make('coup-v0')
+            env.reset()
+
+            history['env'] = env
+            history['ctx'] = ctx
+
+            #valid_actions['label'] = 'hello there'
+
+            for i in range(agents_num):
+                bot_short_memory.append([f'{game_idx+1}th Game Start'])
+                bot_long_memory.append([f'{game_idx+1}th Game Start'])
+
+            status_message = 'Verified.'
+            if game_selection != 'coup':
+                valid_actions = f"{env.get_state(env.get_player_id())['raw_legal_actions']}"
+            else:
+                valid_action_list = env.get_valid_actions(text=True)
+
+            # check if opponent makes move first
+            if game_selection != 'coup':
+                idx = env.get_player_id()
+            else:
+                idx = env.game.whose_action
+            if idx != user_index:
+                amy = ctx.robot_agents[idx]
+                if game_selection != 'coup':
+                    amy_obs = env.get_state(env.get_player_id())['raw_obs']
+                    amy_index = env.get_player_id()
+                    amy_obs['game_num'] = game_idx+1
+                    amy_obs['rest_chips'] = chips[idx]
+                    amy_obs['opponent_rest_chips'] = chips[(idx+1)%agents_num]
+                    valid_action_list = env.get_state(env.get_player_id())['raw_legal_actions']
+                else:
+                    amy_obs =env.get_obs(text=True,p2_view = (idx==1))
+                    amy_index = env.game.whose_action
+                    valid_action_list = env.get_valid_actions(text=True)
+
+                
+                opponent_name  = ctx.robot_agents[(idx+1)%agents_num].name
+
+                act, comm, bot_short_memory, bot_long_memory = amy.make_act(amy_obs, opponent_name, amy_index, valid_action_list, verbose_print=False,
+                                                                            game_idx=game_idx, round=0, bot_short_memory=bot_short_memory, bot_long_memory=bot_long_memory, console=Console(),
+                                                                            log_file_name=None, mode=mode)
+                if game_selection != 'coup':
+                    env.step(act, raw_action=True)
+                else:
+                    env.step(act)
+                    win_message = env.game.call_system_info()
+                    # print(win_message)
+                    if win_message is not None:
+                        print(win_message)
+                        win_message = win_message.replace('Player 0',ctx.robot_agents[0].name)
+                        win_message = win_message.replace('Player 1',ctx.robot_agents[1].name)
+                        
+                        win_message = win_message.replace('I',ctx.robot_agents[idx].name)
+                        win_message = win_message.replace('the opponent',ctx.robot_agents[(idx + 1) % agents_num].name)
+
+                        bot_short_memory.append(win_message)
+                        bot_long_memory.append(win_message)
+
+                dialogue_chatbot.append((None, comm))
+                system_chatbot.append((None, f'Suspicion-Agent action: {act}'))
+
+
+            # get user observation
+            idx = user_index #env.get_player_id()
+            if game_selection != 'coup':
+                amy_obs = env.get_state(idx)['raw_obs']
+                #amy_obs['game_num'] = game_idx+1
+                amy_obs['rest_chips'] = chips[idx]
+                amy_obs['opponent_rest_chips'] = chips[(idx+1)%agents_num]
+
+                valid_actions = env.get_state(idx)['raw_legal_actions']
+            else:
+                amy_obs =env.get_obs(text=True,p2_view = (idx==1))
+                valid_actions = env.get_valid_actions(text=True)
+                
+            if game_selection != 'coup':
+                game_state_string = ""
+                for key, value in amy_obs.items():
+                    if key != 'legal_actions':
+                        game_state_string += f"{key}: {value}\n"
+
+                system_chatbot.append((f'Game state:\n{game_state_string}', None))
+            else:
+                system_chatbot.append((f'Game state:\n{amy_obs}', None))
+            #system_chatbot.append((f'{amy_obs}', None))
+
+            valid_actions = gr.Dropdown.update(choices=valid_actions, value=None)
+            return system_chatbot, dialogue_chatbot, valid_actions, history, chat_counter, status_message
+    #else:
+    #    return system_chatbot, dialogue_chatbot, history, chat_counter, "Already Verified."
+
+    # check if game is over
+    if game_selection != 'coup':
+        game_over = env.is_over()
+    else:
+        game_over = env.game.game_over
+    if game_over:
+        status_message = "Game ended."
+        return system_chatbot, dialogue_chatbot, valid_actions, history, chat_counter, status_message
+
+    if action is None:
+        status_message = "No action received."
+        return system_chatbot, dialogue_chatbot, valid_actions, history, chat_counter, status_message
+    if game_selection != 'coup':
+        if action not in env.get_state(env.get_player_id())['raw_legal_actions']:
+            status_message = "Not a valid action. Please enter a valid action."
+            return system_chatbot, dialogue_chatbot, valid_actions, history, chat_counter, status_message
+    else:
+        if action not in env.get_valid_actions(text=True):
+            status_message = "Not a valid action. Please enter a valid action."
+            return system_chatbot, dialogue_chatbot, valid_actions, history, chat_counter, status_message
+    
+    # message can be empty
+    #if inputs is None or inputs == "":
+    #    status_message += " No message received."
+    #    return system_chatbot, dialogue_chatbot, history, chat_counter, status_message
+    
+    
+    # user takes action
+    if game_selection != 'coup':
+        env_state = env.get_state(env.get_player_id())['raw_obs']
+    else:
+        env_state = env.get_obs(text=True,p2_view = (env.game.whose_action==1))
+    
+    # here action comes from user input
+    #act,_ = rule_model.eval_step(env.get_state(env.get_player_id()))
+    act = action #env.get_state(env.get_player_id())['raw_legal_actions'][0]
+    if game_selection != 'coup':
+        bot_short_memory[(user_index + 1) % agents_num].append(
+            f"The valid action list of {ctx.robot_agents[user_index].name} is {env.get_state(env.get_player_id())['raw_legal_actions']}, and he tries to take action: {act}. He said, {inputs}")
+        # bot_short_memory[(args.user_index) % args.agents_num].append(
+            # f"{ctx.robot_agents[args.user_index].name} have the observation: {env.get_state(env.get_player_id())['raw_obs']}, and try to take action: {act}.")
+        bot_long_memory[(user_index) % agents_num].append(
+            f"{ctx.robot_agents[user_index].name} have the observation: {env.get_state(env.get_player_id())['raw_obs']}, and try to take action: {act}.")
+        # bot_long_memory[(args.user_index) % args.agents_num].append(
+            # f"{ctx.robot_agents[args.user_index].name} try to take action: {act}.")
+    else:
+        bot_short_memory[(user_index + 1) % agents_num].append(
+            f"The valid action list of {ctx.robot_agents[user_index].name} is {env.get_valid_actions(text=True)}, and he tries to take action: {act}. He said, {inputs}")
+        # bot_short_memory[(args.user_index) % args.agents_num].append(
+            # f"{ctx.robot_agents[args.user_index].name} have the observation: {env.get_state(env.get_player_id())['raw_obs']}, and try to take action: {act}.")
+        bot_long_memory[(user_index) % agents_num].append(
+            f"{ctx.robot_agents[user_index].name} have the observation: {env.get_obs(text=True,p2_view = (env.game.whose_action==1))}, and try to take action: {act}.")
+        # bot_long_memory[(args.user_index) % args.agents_num].append(
+            # f"{ctx.robot_agents[args.user_index].name} try to take action: {act}.")
+
+    if game_selection != 'coup':
+        env.step(act, raw_action=True)
+    else:
+        env.step(act)
+
+    comm = None
+    if game_selection != 'coup':
+        game_over = env.is_over()
+    else:
+        game_over = env.game.game_over
+    if not game_over:
+        # opponent move
+        # bot reaction
+        
+        if game_selection != 'coup':
+            idx = env.get_player_id()
+            amy = ctx.robot_agents[idx]
+            amy_index = env.get_player_id()
+            amy_obs = env.get_state(env.get_player_id())['raw_obs']
+            amy_obs['game_num'] = game_idx+1
+            amy_obs['rest_chips'] = chips[idx]
+            amy_obs['opponent_rest_chips'] = chips[(idx+1)%agents_num]
+            valid_action_list = env.get_state(env.get_player_id())['raw_legal_actions']
+        else:
+            idx = env.game.whose_action
+            amy = ctx.robot_agents[idx]
+            amy_index = env.game.whose_action
+            amy_obs = env.get_obs(text=True,p2_view = (idx==1))
+            valid_action_list = env.get_valid_actions(text=True)
+        opponent_name  = ctx.robot_agents[(idx+1)%agents_num].name
+
+        act, comm, bot_short_memory, bot_long_memory = amy.make_act(amy_obs, opponent_name, amy_index, valid_action_list, verbose_print=False,
+                                                                    game_idx=game_idx, round=0, bot_short_memory=bot_short_memory, bot_long_memory=bot_long_memory, console=Console(),
+                                                                    log_file_name=None, mode=mode)
+        if game_selection != 'coup':
+            env.step(act, raw_action=True)
+        else:
+            env.step(act)
+
+    idx = user_index # env.get_player_id()
+    if game_selection != 'coup':
+        amy_obs = env.get_state(idx)['raw_obs']
+    else:
+        amy_obs = env.get_obs(text=True,p2_view = (idx==1))
+    #amy_obs['game_num'] = game_idx+1
+    if game_selection != 'coup':
+        amy_obs['rest_chips'] = chips[idx]
+        amy_obs['opponent_rest_chips'] = chips[(idx+1)%agents_num]
+
+        valid_actions = env.get_state(idx)['raw_legal_actions']
+    else:
+        valid_actions = env.get_valid_actions(text=True)
+
+    game_state_string = ""
+    for key, value in amy_obs.items():
+        if key != 'legal_actions':
+            game_state_string += f"{key}: {value}\n"
+
+    dialogue_chatbot.append((inputs if inputs != "" else None, comm))
+    system_chatbot.append((f'My action: {action}', f'Suspicion-Agent action: {act}'))
+    system_chatbot.append((f'Game state:\n{game_state_string}', None))
+
+    
+    if game_selection != 'coup':
+        if env.is_over():
+            pay_offs = env.get_payoffs()
+            for idx in range(len(pay_offs)):
+                pay_offs[idx] = pay_offs[idx]*2
+                chips[idx] += pay_offs[idx]
+            if pay_offs[user_index] > 0:
+                win_message = f'You win {pay_offs[user_index]} chips, Suspicion-Agent lose {pay_offs[user_index]} chips'
+            else:
+                win_message = f'Suspicion-Agent win {pay_offs[(user_index+1)%agents_num]} chips, you lose {pay_offs[(user_index+1)%agents_num]} chips'
+            
+            idx = (user_index + 1)%agents_num
+            amy_obs = env.get_state(idx)['raw_obs']
+            bot_hand = amy_obs['hand']
+            system_chatbot.append((None, f'Suspicion-Agent hand: {bot_hand}'))
+            system_chatbot.append((f'Gameover.\n {win_message}', None))
+
+            valid_actions = []
+    else:
+        if env.game.game_over:
+            idx = (user_index + 1)%agents_num
+            amy_obs = env.get_obs(text=True,p2_view = (idx==1))
+            bot_hand = amy_obs
+            system_chatbot.append((None, f'Suspicion-Agent hand: {bot_hand}'))
+            system_chatbot.append((f'Gameover.\n {win_message}', None))
+            valid_actions = []
+    status_message += " Message received."
+    valid_actions = gr.Dropdown.update(choices=valid_actions, value=None)
+    return system_chatbot, dialogue_chatbot, valid_actions, history, 1, status_message
+                   
+#Resetting to blank
+def reset_textbox():
+    return gr.update(value='')
+
+#to set a component as visible=False
+def set_visible_false():
+    return gr.update(visible=False)
+
+#to set a component as visible=True
+def set_visible_true():
+    return gr.update(visible=True)
+
+def update_instruction(game_selection):
+    if game_selection is not None and game_selection != '':
+        if game_selection == 'coup':
+            with open('./game_config/coup.json') as file:
+                contents =  json.load(file)
+        elif game_selection == 'leduc-holdem':
+            with open('./game_config/leduc_limit.json') as file:
+                contents =  json.load(file)
+        elif game_selection == 'limit-holdem':
+            with open('./game_config/limit_holdem.json') as file:
+                contents =  json.load(file)
+        return f"Game rule: {contents['game_rule']}\n\n\nObservation Rule: {contents['observation_rule']}"
+
+# update valid actions list
+def set_valid_actions():
+    if game_selection != 'coup':
+        print(env.get_state(env.get_player_id())['raw_legal_actions'])
+    else:
+        print(env.get_valid_actions(text=True))
+    if env is None:
+        return gr.update(value='')
+    else:
+        if game_selection != 'coup':
+            valid_actions_list = env.get_state(env.get_player_id())['raw_legal_actions']
+        else:
+            valid_actions_list = env.get_valid_actions(text=True)
+        return gr.update(value=f'{valid_actions_list}')
+
+title = """<h1 align="center">Suspicion-Agent Demo</h1>"""
+#display message for themes feature
+theme_addon_msg = """<center>This is an official Demo for <b>Suspicion-Agent: Playing Imperfect Information Games with Theory of Mind Aware GPT4</b>. Check out our paper for more details <a href="https://gradio.app/theming-guide/" target="_blank">here</a>!</center>
+""" 
+
+#Using info to add additional information about System message in GPT4
+system_msg_info = """A conversation could begin with a system message to gently instruct the assistant. 
+System message helps set the behavior of the AI Assistant. For example, the assistant could be instructed with 'You are a helpful assistant.'"""
+
+#Modifying existing Gradio Theme
+theme = gr.themes.Soft(primary_hue="zinc", secondary_hue="blue", neutral_hue="blue",
+                      text_size=gr.themes.sizes.text_lg)                
+
+with gr.Blocks(css = """#col_container { margin-left: auto; margin-right: auto;} #chatbot {height: 520px; overflow: auto;}""",
+                      theme=theme) as demo:
+    gr.HTML(title)
+    gr.HTML("""<h3 align="center">🔥This Huggingface Gradio Demo provides a variety of game matches against a GPT4 agent. Please note that you would be needing an OPENAI API key for GPT4 access</h1>""")
+    gr.HTML(theme_addon_msg)
+    gr.HTML('''<center><a href="https://huggingface.co/spaces/paulyoo/suspicion_agent_demo?duplicate=true"><img src="https://bit.ly/3gLdBN6" alt="Duplicate Space"></a>Duplicate the Space and run securely with your OpenAI API Key</center>''')
+
+    initial_state = {
+        'verified': False,
+        'settings': None,
+        'env': None,
+        'ctx': None,
+
+        'bot_long_memory': [],
+        'bot_short_memory': [],
+
+        'agents_num': 2,
+        'chips': [50,50],
+        'user_index': 1,
+        'game_idx': 0,
+        'mode': 'first_tom',
+    }
+
+    with gr.Column(elem_id = "col_container"):
+        #Users need to provide their own GPT4 API key, it is no longer provided by Huggingface 
+        with gr.Row():
+            with gr.Column():
+                openai_gpt4_key = gr.Textbox(label="OpenAI GPT4 Key", value="", type="password", placeholder="sk..", info = "You have to provide your own GPT4 keys for this app to function properly",)
+            with gr.Column():
+                game_selection = gr.Dropdown(
+                    ["leduc-holdem", "limit-holdem","coup"], label="Game Selections", info="Select the game to play from the dropdown"
+                )
+            #with gr.Accordion(label="System message:", open=False):
+            #    system_msg = gr.Textbox(label="Instruct the AI Assistant to set its beaviour", info = system_msg_info, value="",placeholder="Type here..")
+            #    accordion_msg = gr.HTML(value="🚧 To set System message you will have to refresh the app", visible=False)
+
+        with gr.Row():
+            instruction_panel = gr.Textbox(label='Game Instructions')
+
+        with gr.Row():
+            with gr.Column():
+                system_chatbot = gr.Chatbot(label='Game Status', elem_id="system_chatbot")
+            with gr.Column():
+                dialogue_chatbot = gr.Chatbot(label='Dialogue with GPT4', elem_id="dialogue_chatbot")
+
+        #chatbot = gr.Chatbot(label='GPT4', elem_id="chatbot")
+        #action = gr.Radio(['call', 'raise', 'fold'], label="Actions", info="Select the action to play")
+        action = gr.Dropdown(placeholder="", label="Select an action.", info="")
+        inputs = gr.Textbox(placeholder="", label="Type a message for the opponent. Messages are optional.")
+        state = gr.State(initial_state)
+        with gr.Row():
+            with gr.Column(scale=7):
+                b1 = gr.Button().style(full_width=True)
+            with gr.Column(scale=3):
+                server_status_code = gr.Textbox(label="Status code from OpenAI server", )
+    
+        #top_p, temperature
+        with gr.Accordion("Parameters", open=False):
+            top_p = gr.Slider(minimum=-0, maximum=1.0, value=1.0, step=0.05, interactive=True, label="Top-p (nucleus sampling)",)
+            temperature = gr.Slider(minimum=-0, maximum=5.0, value=1.0, step=0.1, interactive=True, label="Temperature",)
+            chat_counter = gr.Number(value=0, visible=False, precision=0)
+
+    #Event handling
+    inputs.submit(predict, [openai_gpt4_key, game_selection, action, inputs, top_p, temperature, chat_counter, dialogue_chatbot, system_chatbot, state], [system_chatbot, dialogue_chatbot, action,  state, chat_counter, server_status_code],)  #openai_api_key
+    b1.click(predict, [openai_gpt4_key, game_selection, action, inputs, top_p, temperature, chat_counter, dialogue_chatbot, system_chatbot, state], [system_chatbot, dialogue_chatbot, action, state, chat_counter, server_status_code],)  #openai_api_key
+    
+    #inputs.submit(set_visible_false, [], [system_msg])
+    #b1.click(set_visible_false, [], [system_msg])
+    #inputs.submit(set_visible_true, [], [accordion_msg])
+    #b1.click(set_visible_true, [], [accordion_msg])
+
+    game_selection.select(update_instruction, [game_selection], [instruction_panel])
+    
+    b1.click(reset_textbox, [], [inputs])
+    inputs.submit(reset_textbox, [], [inputs])
+
+    #b1.click(set_valid_actions, [], [valid_actions])
+    #inputs.submit(set_valid_actions, [], [valid_actions])
+        
+demo.queue(max_size=99, concurrency_count=20).launch(debug=True)

context.py

@@ -0,0 +1,39 @@
+from typing import List
+
+from rich.console import Console
+from rich.prompt import Prompt
+
+from setting import Settings
+from agent import SuspicionAgent
+
+
+class Context:
+    def __init__(self, console: Console, settings: Settings, webcontext=None) -> None:
+        self.clock: int = 0
+        self.console: Console = console
+        self.agents: List[SuspicionAgent] = []
+        self.user_agent: SuspicionAgent = None
+        self.robot_agents: List[SuspicionAgent] = []
+        self.observations = ["Beginning of the day, people are living their lives."]
+        self.timewindow_size = 3
+        self.observations_size_history = []
+        self.settings = settings
+        self.webcontext = webcontext
+
+    def print(self, message: str, style: str = None):
+        if style:
+            self.console.print(message, style=style)
+        else:
+            self.console.print(message)
+
+        if self.webcontext:
+            self.webcontext.send_response(message)
+
+    def ask(self, message: str = "", choices: List[str] = None) -> str:
+        if self.webcontext:
+            return self.webcontext.ask_human(message, choices)
+        else:
+            if choices:
+                return Prompt.ask(message, choices=choices, default=choices[0])
+            else:
+                return Prompt.ask(message)

game_config/coup.json

@@ -0,0 +1,7 @@
+{
+    "name": "Coup",
+    "game_rule":
+       "In the coup game, you play the role of the head of a family in an Italian city-state, a city run by a weak and corrupt court. You need to manipulate, bluff and bribe your way to power. Your object is to destroy the influence of all the other families, forcing them into exile. Only one family will survive...In Coup, you want to be the last player with influence in the game, with influence being represented by face-down character cards in your playing area.  Each player starts the game with two coins and two influence – i.e., two face-down character cards; the fifteen card deck consists of three copies of five different characters, each with a unique set of powers:  Duke: tax: Take three coins from the treasury. block_foreignaid: Block someone from taking foreign aid. Assassin: Assassination: Pay three coins and try to assassinate another player's character Contessa: block_ass: Block an assassination attempt against yourself. Captain: steal: Take two coins from another player, or block_steal: block someone from stealing coins from you. Ambassador: exchange: Draw two character cards from the Court (the deck), choose which (if any) to exchange with your face-down characters, then return two, block_steal: Block someone from stealing coins from you. Note that, the total number of each role is only 3. On your turn, you can take any of the actions listed above, regardless of which characters you actually have in front of you, or you can take one of three other actions: income: Take one coin from the treasury. foreign aid: Take two coins from the treasury. coup: Pay 7 coins and launch a coup against an opponent, forcing that player to lose an influence. (If you have 10 coins or more, you must take this action.) \n Single Win/Loss Rule: When you take one of the character actions – whether actively on your turn, or defensively in response to someone else's action – that character's action automatically succeeds unless an opponent challenges you. In this case, if you can't (or don't) reveal the appropriate character, you lose an influence, turning one of your characters face-up. Face-up characters cannot be used, and if both of your characters are face-up, you're out of the game. If you do have the character in question and choose to reveal it, the opponent loses an influence, then you shuffle that character into the deck and draw a new one, perhaps getting the same character again and perhaps not. The last player to still have influence – that is, a face-down character – wins the game! Win/Loss Payoff Rule: If you let one character of the opponent die or face-up, you will win one chip. If one of your character is face-up or die, you will lose one chip.",
+       "observation_rule":  " You will receive a observation with 21 elements in the list, where the first 4 elements are the role cards of the yours where none denotes the role is hidden but alive or there is no card, The elements in index 9-12 denote whether corresponding cards index 1-4 of yours are dead or not, 0 is alive but hidden, 1 denotes the corresponding card is dead, and none is no this card. Elements index with 5-8 are the role cards of the other player where none denotes the role is alive but hidden or there is no card (depends on following 0/1 numbers), if they have name, that is the name of a dead card. The elements in index 13-16 denote whether corresponding cards in index 5-8 of the other player   are dead or not,  0 is alive but hidden, 1 denotes the corresponding card is dead, and none is no this card. The 17th elements denote the coins the you have. The 18th elements denote the coins the the other player 1. The 19th elements denote the last action the you did.The 20th elements denote the last action the pther player did. Please directly tell me what card I and my opponent have and available to use (Please specify which role card is dead and cannot be used anymore). \n"
+
+}

game_config/leduc_limit.json

@@ -0,0 +1,6 @@
+{
+    "name": "Leduc Hold'em Poker Limit",
+    "game_rule":
+            "Leduc Hold'em is first introduced in Bayes' Bluff: Opponent Modeling in Poker. Note that the deck consists only two cards of King, Queen and Jack, six cards in total. Each game is fixed with two players, only two rounds. Note that only one public hand is available, two-bet maximum. Raise action: In the first round, you will put chips with amounts of 4 more than chips of your opponent, in the following round, you will put chips with amounts of 8 more than chips of your opponent. Call action: you will put chips with same amounts as your opponent (if his chips in pot are higher than yours, normally 4 ).   In the first round, one player is randomly choosed to put 1 unit in pot as small blind while the other puts 2 unit as big blind, and each player is dealt one card, then starts betting. The player with small blind acts first. In the second round, one public card is revealed first, then the players bet again. (Only one public card is available in the whole game.)   \n Single Game Win/Draw/Lose Rule: the player whose hand has the same rank as the public card is the winner of one round game. If neither, then the one with higher rank wins this round game, if the rank of cards of two players are the same, it is draw. you can also 'fold' in one round game.  \n Whole Game Win/Draw/Lose Rule: you are requested to attend 100 games with your opponent, you both are given 100 chips originally, and the guy who have more chips will win the game after 100 games (i.e. You aim to have more chips than your original chips). \n Winning Payoff Rule:  The half of  the total  pot. \n Lose Payoff Rule:  The half of the total pot. ",
+         "observation_rule": "The observation is a dictionary. The main observation space: `'raw_legal_actions'` which holds the legal moves, described in the Legal Actions Mask section. 'hand' is the hole hand, where SJ denotes the J of Spades, HK denotes King of Hearts.   game_num is the idx of game now, the total number is 100. all_chips is list which contains the number of chips you and the opponent has been put in the pot, respectively, where the first element of 'all_chips' is the number of chips you have put in the pot, the second element of 'all_chips' is the number of chips the opponent have put in the pot.  rest_chips is how much chips you have now, opponent_rest_chips how much chips your opponent have now. Based on your hole hand and public hand (only one), please analysis what is your best combination now and potential combinations in future with probability (number) reasonably and accurately step by step."
+}

game_config/limit_holdem.json

@@ -0,0 +1,6 @@
+{
+    "name": "Texas Hold'em Poker Limit",
+    "game_rule":
+            "General Rule: There are the basic rules for Texas Hold'em Poker limit with a limit betting structure:\n\nIn this game, you are requested to attend 40 games with your opponent, you both are given 20 chips originally, and the guy who have more chips will win the game after 40 games, note that if your chips become 0 or negatives, you will loss the whole game. The goal of you is to obtain more chips than your opponent.  The Deck: Texas Hold'em is played with a standard deck of 52 cards, where there are 13 number cards (A,1 to K) with 4 colors.\n\nThe Blinds: The game begins with two players to the left of the dealer posting a small blind and a big blind respectively. The small blind is usually half of the big blind.\n\nDealing the Cards: Each player is then dealt two private cards known as 'hole cards' that belong to them alone.\n\nFirst Round of Betting: Starting with the player to the left of the big blind, each player can call the big blind, raise, or fold. In limit hold'em, the amount that a player can raise in the first two rounds of betting (pre-flop and flop) is set at the lower limit of the stakes structure. For instance, in a $4/$8 limit hold'em game, players can bet and raise in increments of $8 during the pre-flop and flop rounds.\n\nThe Flop: After the first round of betting, the dealer discards the top card of the deck (a move called 'burning' the card) and then deals three face-up community cards known as the flop.\n\nSecond Round of Betting: Another round of betting ensues, starting with the player to the left of the dealer. The same betting rules apply as the first round.\n\nThe Turn: The dealer burns another card and then adds a fourth face-up card to the community cards. This fourth card is known as the turn.\n\nThird Round of Betting: Another round of betting starts. In limit hold'em, the betting limit now doubles. So in our $4/$8 game example, players can now bet and raise in increments of $8.\n\nThe River: The dealer burns another card before placing a fifth and final community card face-up on the table. This card is known as the river.\n\nFinal Round of Betting: The final round of betting starts with the same rules as the third round.\n\nThe Showdown: If two or more players remain after the final round of betting, a showdown occurs. This is where players reveal their hands, and the player with the best hand wins the pot. \n Single Game Win/Draw/Lose Rule: Texas Hold'em hands are ranked from highest to lowest as follows: Royal Flush, Straight Flush, Four of a Kind, Full House, Flush, Straight, Three of a Kind, Two Pair, One Pair, High Card.\n\nNote: If at any point a player makes a bet or a raise that no other player calls, they win the pot without revealing their hand.\n\nRotating the Dealer: After the pot is awarded, the dealer button moves one seat to the left, and the process begins anew.\nThe main difference between Limit Hold'em and other betting structures like No Limit or Pot Limit is the amount a player can bet or raise. In Limit, the amount is capped at a set amount per round. \n Whole Game Win/Draw/Lose Rule: you are requested to attend 10 games with your opponent, you both are given 50 chips originally, and the guy who have more chips will win the game after 10 games (i.e. You aim to have more chips than your original chips). \n Winning Payoff Rule:  The half of  the pot. \n Lose Payoff Rule:  The half of  the pot. ",
+    "observation_rule": "The observation is a dictionary which contains an `'observation'` element which is the usual RL observation described below, and an  `'raw_legal_actions'` which holds the legal moves, described in the Legal Actions Mask section. The main observation space is similar to Texas Hold'em. 'hand' is the hole hand, where H3 denotes the 3 of diamonds, ST denotes 10 of Spades.   raise_nums is a list with 4 numbers which represents the how many times you have raised in 4 rounds. Specifically, you have no more than 4 chances to raise in each round. action_record denotes the action history of the current game. The first dimension is the agent number, the second dimension is the action type. game_num is the idx of game now, the total number is 40. rest_chips is how much chips you have now, opponent_rest_chips how much chips your opponent have now. Based on your hole hand and public hands, please analysis what is your best combination now and potential combinations in future with probability (number 100% total) reasonably step by step."
+}

model.py

@@ -0,0 +1,99 @@
+from typing import Dict, List, Type
+
+from langchain import chat_models, embeddings, llms
+from langchain.embeddings.base import Embeddings
+from langchain.llms.base import BaseLanguageModel
+
+from setting import EmbeddingSettings, LLMSettings
+from context import Context
+from setting import Settings
+from rich.console import Console
+from agent import SuspicionAgent
+
+def agi_init(
+    agent_configs: List[dict],
+    game_config:dict,
+    console: Console,
+    settings: Settings,
+    user_idx: int = 0,
+    webcontext=None,
+) -> Context:
+    ctx = Context(console, settings, webcontext)
+    ctx.print("Creating all agents one by one...", style="yellow")
+    for idx, agent_config in enumerate(agent_configs):
+        agent_name = agent_config["name"]
+        with ctx.console.status(f"[yellow]Creating agent {agent_name}..."):
+            agent = SuspicionAgent(
+                name=agent_config["name"],
+                age=agent_config["age"],
+                rule=game_config["game_rule"],
+                game_name=game_config["name"],
+                observation_rule=game_config["observation_rule"],
+                status="N/A",  
+                llm=load_llm_from_config(ctx.settings.model.llm),
+            
+                reflection_threshold=8,
+            )
+            for memory in agent_config["memories"]:
+                agent.add_memory(memory)
+        ctx.robot_agents.append(agent)
+        ctx.agents.append(agent)
+    
+        ctx.print(f"Agent {agent_name} successfully created", style="green")
+
+    ctx.print("Suspicion Agent started...")
+   
+    return ctx
+
+
+
+# ------------------------- LLM/Chat models registry ------------------------- #
+llm_type_to_cls_dict: Dict[str, Type[BaseLanguageModel]] = {
+    "chatopenai": chat_models.ChatOpenAI,
+    "openai": llms.OpenAI,
+}
+
+# ------------------------- Embedding models registry ------------------------ #
+embedding_type_to_cls_dict: Dict[str, Type[Embeddings]] = {
+    "openaiembeddings": embeddings.OpenAIEmbeddings
+}
+
+
+# ---------------------------------------------------------------------------- #
+#                                LLM/Chat models                               #
+# ---------------------------------------------------------------------------- #
+def load_llm_from_config(config: LLMSettings) -> BaseLanguageModel:
+    """Load LLM from Config."""
+    config_dict = config.dict()
+    config_type = config_dict.pop("type")
+
+    if config_type not in llm_type_to_cls_dict:
+        raise ValueError(f"Loading {config_type} LLM not supported")
+
+    cls = llm_type_to_cls_dict[config_type]
+    return cls(**config_dict)
+
+
+def get_all_llms() -> List[str]:
+    """Get all supported LLMs"""
+    return list(llm_type_to_cls_dict.keys())
+
+
+# ---------------------------------------------------------------------------- #
+#                               Embeddings models                              #
+# ---------------------------------------------------------------------------- #
+def load_embedding_from_config(config: EmbeddingSettings) -> Embeddings:
+    """Load Embedding from Config."""
+    config_dict = config.dict()
+    config_type = config_dict.pop("type")
+    print(config)
+    if config_type not in embedding_type_to_cls_dict:
+        raise ValueError(f"Loading {config_type} Embedding not supported")
+
+    cls = embedding_type_to_cls_dict[config_type]
+    return cls(**config_dict)
+
+
+def get_all_embeddings() -> List[str]:
+    """Get all supported Embeddings"""
+    return list(embedding_type_to_cls_dict.keys())

person_config/GoodGuy.json

@@ -0,0 +1,6 @@
+{
+    "name": "GoodGuy",
+    "age": 27,
+    "personality": "flexible",
+    "memories":[]
+}

person_config/Persuader.json

@@ -0,0 +1,6 @@
+{
+    "name": "board_game_expert",
+    "age": 27,
+    "personality": "flexible",
+    "memories":[]
+}

requirements.txt

@@ -0,0 +1,16 @@
+rich
+textual
+typer
+termcolor
+tiktoken
+faiss-cpu
+openai
+pinecone-client
+langchain
+discord.py
+inquirer
+rlcard[torch]
+python-json-logger
+gitpython
+gym
+git+https://github.com/CR-Gjx/gym-coup.git

retriever.py

@@ -0,0 +1,73 @@
+import os
+import pickle
+from langchain import FAISS
+from langchain.retrievers import TimeWeightedVectorStoreRetriever
+from langchain.embeddings.base import Embeddings
+import faiss
+from  context import  Context
+from model import load_embedding_from_config
+import math
+from langchain.docstore import InMemoryDocstore
+
+# reference:
+# https://python.langchain.com/en/latest/use_cases/agent_simulations/characters.html#create-a-generative-character
+def relevance_score_fn(score: float) -> float:
+    """Return a similarity score on a scale [0, 1]."""
+    # This will differ depending on a few things:
+    # - the distance / similarity metric used by the VectorStore
+    # - the scale of your embeddings (OpenAI's are unit norm. Many others are not!)
+    # This function converts the euclidean norm of normalized embeddings
+    # (0 is most similar, sqrt(2) most dissimilar)
+    # to a similarity function (0 to 1)
+    return 1.0 - score / math.sqrt(2)
+
+
+# reference:
+# https://python.langchain.com/en/latest/use_cases/agent_simulations/characters.html#create-a-generative-character
+def create_new_memory_retriever(ctx: Context):
+    """Create a new vector store retriever unique to the agent."""
+    # Define your embedding model
+    embeddings_model = load_embedding_from_config(ctx.settings.model.embedding)
+    # Initialize the vectorstore as empty
+    embedding_size = 1536
+    index = faiss.IndexFlatL2(embedding_size)
+    vectorstore = FAISS(
+        embeddings_model.embed_query,
+        index,
+        InMemoryDocstore({}),
+        {},
+        relevance_score_fn=relevance_score_fn,
+    )
+    return TimeWeightedVectorStoreRetriever(
+        vectorstore=vectorstore, other_score_keys=["importance"], k=15
+    )
+
+
+class Retriever(TimeWeightedVectorStoreRetriever):
+    embedding_model: Embeddings
+
+    def faiss_path(self, path) -> str:
+        return path + "/faiss"
+
+    def mem_path(self, path) -> str:
+        return path + "/memory.pickle"
+
+    def try_load_memory(self, path: str) -> bool:
+        if not os.path.isdir(path):
+            return False
+
+        faiss_path = self.faiss_path(path)
+        faiss: FAISS = self.vectorstore
+        faiss.load_local(faiss_path, self.embedding_model)
+
+        mem_path = self.mem_path(path)
+        with open(mem_path, "rb") as mem_file:
+            self.memory_stream = pickle.load(mem_file)
+
+        return True
+
+    def dump_memory(self, path: str) -> bool:
+        faiss: FAISS = self.vectorstore
+        faiss.save_local(self.faiss_path(path))
+        with open(self.mem_path(path), "wb") as mem_file:
+            pickle.dump(self.memory_stream, mem_file)

setting.py

@@ -0,0 +1,139 @@
+from pathlib import Path
+from typing import Any, Dict, List, Type
+
+from pydantic import BaseModel, BaseSettings, Extra
+import os
+
+def json_config_settings_source(settings: BaseSettings) -> Dict[str, Any]:
+    from util import load_json
+
+    # Load settings from JSON config file
+    config_dir = Path(os.getcwd(), ".suspicionagent")
+    config_file = Path(config_dir, "config.json")
+    if not config_dir.exists() or not config_file.exists():
+        print("[Error] Please config suspicionagent")
+        import sys
+
+        sys.exit(-1)
+    return load_json(config_file)
+
+
+class LLMSettings(BaseModel):
+    """
+    LLM/ChatModel related settings
+    """
+
+    type: str = "chatopenai"
+
+    class Config:
+        extra = Extra.allow
+
+
+class EmbeddingSettings(BaseModel):
+    """
+    Embedding related settings
+    """
+
+    type: str = "openaiembeddings"
+
+    class Config:
+        extra = Extra.allow
+
+
+class ModelSettings(BaseModel):
+    """
+    Model related settings
+    """
+
+    type: str = ""
+    llm: LLMSettings = LLMSettings()
+    embedding: EmbeddingSettings = EmbeddingSettings()
+
+    class Config:
+        extra = Extra.allow
+
+
+class Settings(BaseSettings):
+    """
+    Root settings
+    """
+
+    name: str = "default"
+    model: ModelSettings = ModelSettings()
+
+    class Config:
+        env_prefix = "skyagi_"
+        env_file_encoding = "utf-8"
+        extra = Extra.allow
+
+        @classmethod
+        def customise_sources(
+            cls,
+            init_settings,
+            env_settings,
+            file_secret_settings,
+        ):
+            return (
+                init_settings,
+                #json_config_settings_source,
+                env_settings,
+                file_secret_settings,
+            )
+
+
+# ---------------------------------------------------------------------------- #
+#                             Preset configurations                            #
+# ---------------------------------------------------------------------------- #
+class OpenAIGPT4Settings(ModelSettings):
+    # NOTE: GPT4 is in waitlist
+    type = "openai-gpt-4-0613"
+    llm = LLMSettings(type="chatopenai", model="gpt-4-0613", max_tokens=3000,temperature=0.1,  request_timeout=120)
+    embedding = EmbeddingSettings(type="openaiembeddings")
+
+class OpenAIGPT432kSettings(ModelSettings):
+    # NOTE: GPT4 is in waitlist
+    type = "openai-gpt-4-32k-0613"
+    llm = LLMSettings(type="chatopenai", model="gpt-4-32k-0613", max_tokens=2500)
+    embedding = EmbeddingSettings(type="openaiembeddings")
+
+
+class OpenAIGPT3_5TurboSettings(ModelSettings):
+    type = "openai-gpt-3.5-turbo"
+    llm = LLMSettings(type="chatopenai", model="gpt-3.5-turbo-16k-0613", max_tokens=2500)
+    embedding = EmbeddingSettings(type="openaiembeddings")
+
+
+class OpenAIGPT3_5TextDavinci003Settings(ModelSettings):
+    type = "openai-gpt-3.5-text-davinci-003"
+    llm = LLMSettings(type="openai", model_name="text-davinci-003", max_tokens=2500)
+    embedding = EmbeddingSettings(type="openaiembeddings")
+
+# class Llama2_70b_Settings(ModelSettings):
+#     from transformers import LlamaForCausalLM, LlamaTokenizer
+#     type = "llama2-70b"
+#     tokenizer = LlamaTokenizer.from_pretrained("/groups/gcb50389/pretrained/llama2-HF/Llama-2-70b-hf")
+#     llm = LlamaForCausalLM.from_pretrained("/groups/gcb50389/pretrained/llama2-HF/Llama-2-70b-hf")
+#     embedding = EmbeddingSettings(type="openaiembeddings")
+
+
+# ------------------------- Model settings registry ------------------------ #
+model_setting_type_to_cls_dict: Dict[str, Type[ModelSettings]] = {
+    "openai-gpt-4-0613": OpenAIGPT4Settings,
+    "openai-gpt-4-32k-0613": OpenAIGPT432kSettings,
+    "openai-gpt-3.5-turbo": OpenAIGPT3_5TurboSettings,
+    "openai-gpt-3.5-text-davinci-003": OpenAIGPT3_5TextDavinci003Settings,
+    # "llama2-70b":Llama2_70b_Settings
+}
+
+
+def load_model_setting(type: str) -> ModelSettings:
+    if type not in model_setting_type_to_cls_dict:
+        raise ValueError(f"Loading {type} setting not supported")
+
+    cls = model_setting_type_to_cls_dict[type]
+    return cls()
+
+
+def get_all_model_settings() -> List[str]:
+    """Get all supported Embeddings"""
+    return list(model_setting_type_to_cls_dict.keys())

util.py

@@ -0,0 +1,127 @@
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict
+
+from model import load_embedding_from_config, load_llm_from_config
+from setting import Settings
+import logging
+from pythonjsonlogger import jsonlogger
+
+
+
+def verify_openai_token(token: str) -> str:
+    import openai
+
+    openai.api_key = token
+    try:
+        openai.Completion.create(
+            model="text-ada-001",
+            prompt="Hello",
+            temperature=0,
+            max_tokens=10,
+            top_p=1,
+            frequency_penalty=0.5,
+            presence_penalty=0,
+        )
+        return "OK"
+    except Exception as e:
+        return str(e)
+
+def get_logging(logger_name,content=''):
+    logger = logging.getLogger(logger_name)
+    if not logger.handlers:
+        logger.setLevel(logging.DEBUG)
+        logHandlerJson = logging.FileHandler('./memory_data/'+logger_name+'.json')
+        formatter = jsonlogger.JsonFormatter()
+        logHandlerJson.setFormatter(formatter)
+
+        # handler = logging.FileHandler('./memory_data/'+logger_name+'.txt')
+        # handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
+        logger.addHandler(logHandlerJson)
+    logger.info(content)
+
+
+def verify_model_initialization(settings: Settings) -> str:
+    try:
+        load_llm_from_config(settings.model.llm)
+    except Exception as e:
+        return f"LLM initialization check failed: {e}"
+
+    try:
+        load_embedding_from_config(settings.model.embedding)
+    except Exception as e:
+        return f"Embedding initialization check failed: {e}"
+
+    return "OK"
+
+
+def verify_pinecone_token(token: str) -> str:
+    return "OK"
+
+
+def verify_discord_token(token: str) -> str:
+    return "OK"
+
+
+def load_json_value(filepath: Path, key: str, default_value: Any) -> Any:
+    if not Path(filepath).exists():
+        return default_value
+    json_obj = load_json(filepath)
+    if key not in json_obj:
+        return default_value
+    return json_obj[key]
+
+
+def set_json_value(filepath: Path, key: str, value: Any) -> None:
+    # key needs to follow python naming convention, such as trial_id
+    json_obj = load_json(filepath)
+    json_obj[key] = value
+    with open(filepath, "w+") as json_file:
+        json.dump(json_obj, json_file, sort_keys=True)
+        json_file.flush()
+
+
+def load_json(filepath: Path) -> Dict:
+    if not Path(filepath).exists():
+        return {}
+    with open(filepath, "r") as file:
+        try:
+            json_obj = json.load(file)
+            return json_obj
+        except json.JSONDecodeError as e:
+            if os.stat(filepath).st_size == 0:
+                # Empty file
+                return {}
+            else:
+                raise e
+
+def load_log(file_name, key_name):
+    content_list = []
+    key_list = []
+    with open('./memory_data/'+file_name) as f:
+        contents = f.readlines()
+        for i in contents:
+            print(i)
+            contents =  json.loads(i)
+            content_list.append(list(contents.values())[1][key_name])
+            key_list.append(list(contents.keys())[1])
+    return content_list, key_list
+
+def load_log_full(file_name, key_name):
+    content_list = []
+    key_list = []
+    with open(file_name) as f:
+        contents = f.readlines()
+        for i in contents:
+            #print(i)
+            contents = json.loads(i)
+            if key_name is None:
+                content_list.append(list(contents.values())[1])
+            else:
+                content_list.append(list(contents.values())[1][key_name])
+            key_list.append(list(contents.keys())[1])
+    return content_list, key_list
+
+def get_checkpoint_dir(agent_file: str) -> str:
+    return "./{}.cpt".format(os.path.basename(agent_file))