Human in the loop and develop a Social Media Game

oasis/social_agent/agent.py

@@ -16,17 +16,19 @@
 import inspect
 import json
 import logging
+import random
 import sys
 from datetime import datetime
 from typing import TYPE_CHECKING, Any
 
-from camel.configs import ChatGPTConfig
+from camel.agents._utils import convert_to_schema
 from camel.memories import (ChatHistoryMemory, MemoryRecord,
                             ScoreBasedContextCreator)
-from camel.messages import BaseMessage
+from camel.messages import BaseMessage, FunctionCallingMessage
 from camel.models import ModelFactory
 from camel.types import ModelPlatformType, ModelType, OpenAIBackendRole
 from camel.utils import OpenAITokenCounter
+from tenacity import retry, stop_after_attempt, wait_random_exponential
 
 from oasis.social_agent.agent_action import SocialAction
 from oasis.social_agent.agent_environment import SocialEnvironment
@@ -67,30 +69,28 @@ def __init__(
         self.twitter_channel = twitter_channel
         self.infe_channel = inference_channel
         self.env = SocialEnvironment(SocialAction(agent_id, twitter_channel))
-        self.system_message = BaseMessage.make_assistant_message(
-            role_name="User",
-            content=self.user_info.to_system_message(action_space_prompt),
-        )
         self.model_type = model_type
         self.is_openai_model = is_openai_model
         if self.is_openai_model:
-            model_config = ChatGPTConfig(
-                tools=self.env.action.get_openai_function_list(),
-                temperature=0.5,
-            )
+            tools = self.env.action.get_openai_function_list()
+            tool_schemas = {
+                tool_schema["function"]["name"]: tool_schema
+                for tool_schema in [convert_to_schema(tool) for tool in tools]
+            }
+            self.full_tool_schemas = list(tool_schemas.values())
             self.model_backend = ModelFactory.create(
                 model_platform=ModelPlatformType.OPENAI,
                 model_type=ModelType(model_type),
-                model_config_dict=model_config.as_dict(),
             )
+            self.model_backend.model_config_dict['temperature'] = 0.6
 
         context_creator = ScoreBasedContextCreator(
             OpenAITokenCounter(ModelType.GPT_3_5_TURBO),
             4096,
         )
         self.memory = ChatHistoryMemory(context_creator, window_size=5)
         self.system_message = BaseMessage.make_assistant_message(
-            role_name="system",
+            role_name="System",
             content=self.user_info.to_system_message(
                 action_space_prompt),  # system prompt
         )
@@ -105,6 +105,8 @@ def __init__(
             "\n"
             "What do you think Helen should do?")
 
+    @retry(wait=wait_random_exponential(min=1, max=60),
+           stop=stop_after_attempt(6))
     async def perform_action_by_llm(self):
         # Get posts:
         env_prompt = await self.env.to_text_prompt()
@@ -141,24 +143,94 @@ async def perform_action_by_llm(self):
                 "role": self.system_message.role_name,
                 "content": self.system_message.content,
             }] + [user_msg.to_openai_user_message()]
-        agent_log.info(
-            f"Agent {self.agent_id} is running with prompt: {openai_messages}")
+
+        # agent_log.info(
+        #     f"Agent {self.agent_id} is running with prompt: "
+        #     f"{openai_messages}")
 
         if self.is_openai_model:
+            full_tool_schemas = self.full_tool_schemas
+            self_description = self.user_info.to_description()
+            for func_index in [0, 1]:
+                full_tool_schemas[func_index]["function"]["parameters"][
+                    'properties']['content']['description'] += self_description
+            full_tool_schemas[2]["function"]["parameters"]['properties'][
+                'quote_content']['description'] += self_description
+
+            mean_prob = 0.5
+            mean_prompt = """
+你是一个以幽默、反讽、mean、猎奇、刻薄著称的X博主，你非常擅长使用网络热梗和网上冲浪。并且很了解目前创业投资圈的资讯。挥你幽默反讽的风格。
+"""
+            long_content_prob = 1
+            long_comment_prob = 0.5
+            long_quote_prob = 0.5
+            num_words_long = 50
+            long_prompt = f"""
+Note that content should exceed {num_words_long} words.
+"""
+            if random.random() < mean_prob:
+                full_tool_schemas[0]["function"]["parameters"]['properties'][
+                    'content']['description'] += mean_prompt
+            if random.random() < long_content_prob:
+                full_tool_schemas[0]["function"]["parameters"]['properties'][
+                    'content']['description'] += long_prompt
+            if random.random() < long_comment_prob:
+                full_tool_schemas[1]["function"]["parameters"]['properties'][
+                    'content']['description'] += long_prompt
+            if random.random() < long_quote_prob:
+                full_tool_schemas[2]["function"]["parameters"]['properties'][
+                    'quote_content']['description'] += long_prompt
             try:
-                response = self.model_backend.run(openai_messages)
-                agent_log.info(f"Agent {self.agent_id} response: {response}")
-                content = response
+                response = await self.model_backend._arun(
+                    openai_messages, tools=self.full_tool_schemas)
+                # agent_log.info(f"Agent {self.agent_id} response: {response}")
+                # print(f"Agent {self.agent_id} response: {response}")
                 for tool_call in response.choices[0].message.tool_calls:
                     action_name = tool_call.function.name
                     args = json.loads(tool_call.function.arguments)
                     print(f"Agent {self.agent_id} is performing "
                           f"action: {action_name} with args: {args}")
-                    await getattr(self.env.action, action_name)(**args)
+                    result = await getattr(self.env.action,
+                                           action_name)(**args)
                     self.perform_agent_graph_action(action_name, args)
+                    assist_msg = FunctionCallingMessage(
+                        role_name="Twitter User",
+                        role_type=OpenAIBackendRole.ASSISTANT,
+                        meta_dict=None,
+                        content="",
+                        func_name=action_name,
+                        args=args,
+                        tool_call_id=tool_call.id,
+                    )
+                    func_msg = FunctionCallingMessage(
+                        role_name="Twitter User",
+                        role_type=OpenAIBackendRole.ASSISTANT,
+                        meta_dict=None,
+                        content="",
+                        func_name=action_name,
+                        result=result,
+                        tool_call_id=tool_call.id,
+                    )
+                    self.memory.write_record(
+                        MemoryRecord(
+                            message=assist_msg,
+                            role_at_backend=OpenAIBackendRole.ASSISTANT,
+                        ))
+                    self.memory.write_record(
+                        MemoryRecord(
+                            message=func_msg,
+                            role_at_backend=OpenAIBackendRole.FUNCTION,
+                        ))
+
             except Exception as e:
-                print(e)
+                print(f"Agent {self.agent_id} error: {e}")
+                print(openai_messages)
                 content = "No response."
+                agent_msg = BaseMessage.make_assistant_message(
+                    role_name="Assistant", content=content)
+                self.memory.write_record(
+                    MemoryRecord(message=agent_msg,
+                                 role_at_backend=OpenAIBackendRole.ASSISTANT))
 
         else:
             retry = 5
@@ -176,8 +248,8 @@ async def perform_action_by_llm(self):
                 mes_id, content = await self.infe_channel.read_from_send_queue(
                     mes_id)
 
-                agent_log.info(
-                    f"Agent {self.agent_id} receive response: {content}")
+                # agent_log.info(
+                #     f"Agent {self.agent_id} receive response: {content}")
 
                 try:
                     content_json = json.loads(content)
@@ -214,19 +286,14 @@ async def perform_action_by_llm(self):
 
             if retry == 0:
                 content = "No response."
-        agent_msg = BaseMessage.make_assistant_message(role_name="Assistant",
-                                                       content=content)
-        self.memory.write_record(
-            MemoryRecord(message=agent_msg,
-                         role_at_backend=OpenAIBackendRole.ASSISTANT))
 
     async def perform_test(self):
         """
         doing test for all agents.
         """
         # user conduct test to agent
         _ = BaseMessage.make_user_message(role_name="User",
-                                          content=("You are a twitter user."))
+                                          content="You are a twitter user.")
         # TODO error occurs
         # self.memory.write_record(MemoryRecord(user_msg,
         #                                       OpenAIBackendRole.USER))
@@ -242,27 +309,27 @@ async def perform_test(self):
             "role": "user",
             "content": self.test_prompt
         }])
-        agent_log.info(f"Agent {self.agent_id}: {openai_messages}")
+        # agent_log.info(f"Agent {self.agent_id}: {openai_messages}")
 
         message_id = await self.infe_channel.write_to_receive_queue(
             openai_messages)
         message_id, content = await self.infe_channel.read_from_send_queue(
             message_id)
-        agent_log.info(f"Agent {self.agent_id} receive response: {content}")
+        # agent_log.info(f"Agent {self.agent_id} receive response: {content}")
         return {
             "user_id": self.agent_id,
             "prompt": openai_messages,
             "content": content
         }
 
-    async def perform_action_by_hci(self) -> Any:
+    async def perform_action_by_hci(self, input_content: str, selection:int = 0) -> Any:
         print("Please choose one function to perform:")
         function_list = self.env.action.get_openai_function_list()
-        for i in range(len(function_list)):
-            agent_log.info(f"Agent {self.agent_id} function: "
-                           f"{function_list[i].func.__name__}")
+        # for i in range(len(function_list)):
+        #     agent_log.info(f"Agent {self.agent_id} function: "
+        #                    f"{function_list[i].func.__name__}")
 
-        selection = int(input("Enter your choice: "))
+        # selection = int(input("Enter your choice: "))
         if not 0 <= selection < len(function_list):
             agent_log.error(f"Agent {self.agent_id} invalid input.")
             return
@@ -273,7 +340,8 @@ async def perform_action_by_hci(self) -> Any:
         for param in params.values():
             while True:
                 try:
-                    value = input(f"Enter value for {param.name}: ")
+                    # value = input(f"Enter value for {param.name}: ")
+                    value = input_content
                     args.append(value)
                     break
                 except ValueError:
@@ -288,7 +356,7 @@ async def perform_action_by_data(self, func_name, *args, **kwargs) -> Any:
             if function_list[i].func.__name__ == func_name:
                 func = function_list[i].func
                 result = await func(*args, **kwargs)
-                agent_log.info(f"Agent {self.agent_id}: {result}")
+                # agent_log.info(f"Agent {self.agent_id}: {result}")
                 return result
         raise ValueError(f"Function {func_name} not found in the list.")
 

oasis/social_agent/agent_action.py

@@ -13,7 +13,7 @@
 # =========== Copyright 2023 @ CAMEL-AI.org. All Rights Reserved. ===========
 from typing import Any
 
-from camel.toolkits import OpenAIFunction
+from camel.toolkits import FunctionTool
 
 from oasis.social_platform.channel import Channel
 from oasis.social_platform.typing import ActionType
@@ -25,31 +25,16 @@ def __init__(self, agent_id: int, channel: Channel):
         self.agent_id = agent_id
         self.channel = channel
 
-    def get_openai_function_list(self) -> list[OpenAIFunction]:
+    def get_openai_function_list(self) -> list[FunctionTool]:
         return [
-            OpenAIFunction(func) for func in [
+            FunctionTool(func) for func in [
                 self.create_post,
-                self.like_post,
-                self.repost,
-                self.quote_post,
-                self.unlike_post,
-                self.dislike_post,
-                self.undo_dislike_post,
-                self.search_posts,
-                self.search_user,
-                self.trend,
-                self.refresh,
-                self.do_nothing,
                 self.create_comment,
+                self.quote_post,
+                self.repost,
                 self.like_comment,
-                self.dislike_comment,
-                self.unlike_comment,
-                self.undo_dislike_comment,
-                self.follow,
-                self.unfollow,
-                self.mute,
-                self.unmute,
-                self.purchase_product,
+                self.like_post,
+                self.do_nothing,
             ]
         ]
 
@@ -143,7 +128,9 @@ async def create_post(self, content: str):
         dictionary indicating success and the ID of the newly created post.
 
         Args:
-            content (str): The content of the post to be created.
+            content (str): The content of the post to be created. Please
+                includes more emojis and hashtags to make your post more
+                attractive.
 
         Returns:
             dict: A dictionary with two key-value pairs. The 'success' key
@@ -191,7 +178,9 @@ async def quote_post(self, post_id: int, quote_content: str):
 
         Args:
             post_id (int): The ID of the post to be quoted.
-            quote_content (str): The content of the quote to be created.
+            quote_content (str): The content of the quote to be created. Please
+                includes more emojis and hashtags to make your post more
+                attractive.
 
         Returns:
             dict: A dictionary with two key-value pairs. The 'success' key

oasis/social_agent/agents_generator.py

@@ -499,6 +499,7 @@ async def gen_control_agents_with_data(
         name = "momo"
         bio = "None."
         response = await agent.env.action.sign_up(user_name, name, bio)
+        print(response)
         user_id = response["user_id"]
         agent_user_id_mapping[i] = user_id
 
@@ -540,12 +541,14 @@ async def process_agent(i):
         profile["other_info"]["gender"] = agent_info[i]["gender"]
         profile["other_info"]["age"] = agent_info[i]["age"]
         profile["other_info"]["country"] = agent_info[i]["country"]
+        profile["other_info"]["profession"] = agent_info[i]["profession"]
+        profile["other_info"]["realname"] = agent_info[i]["realname"]
 
         user_info = UserInfo(
             name=agent_info[i]["username"],
             description=agent_info[i]["bio"],
             profile=profile,
-            recsys_type="reddit",
+            recsys_type="twitter",
         )
 
         agent = SocialAgent(