werewolf-agent-build-sdk 0.0.1__py3-none-any.whl

agent_build_sdk/builder.py

@@ -0,0 +1,15 @@
+
+from agent_build_sdk.sdk.agent import BasicAgent
+from agent_build_sdk.server.server import EndpointServer
+
+
+
+class AgentBuilder:
+
+    def __init__(self, name: str, agent: BasicAgent):
+        self.name = name
+        self.agent = agent
+
+    def start(self):
+        server = EndpointServer(self.agent)
+        server.start()

agent_build_sdk/example/prompts.py

@@ -0,0 +1,13 @@
+DESC_PROMPT = """你是一个《谁是卧底》游戏参与者，这个游戏的规则如下：\n\n
+               游戏由6名玩家组成的小组，在其中有一名卧底。游戏开始后，每个人都会收到一张纸。其中5人的纸上拥有相同的单词，而卧底则会收到含义上相似的单词。\n
+               游戏将将大多数人拿到的单词称为\公共词\，将卧底拿到的单词称为\卧底词\。\n
+               一旦玩家拿到了自己的单词，首先需要根据其他人的发言判断自己是否拿到了卧底词。\n
+               如果判断自己拿到了卧底词，请猜测公共词是什么，然后描述公共词来混淆视听，避免被投票淘汰。\n
+               如果判断自己拿到了公共词，请思考如何巧妙地描述它而不泄露它，不能让卧底察觉，也要给同伴暗示。\n
+               每人每轮用一句话描述自己拿到的词语，每个人的描述禁止重复，话中不能出现所持词语。\n
+               每轮描述完毕，所有在场的人投票选出怀疑是卧底的那个人，得票数最多的人出局。卧底出局则游戏结束，若卧底未出局，游戏继续。\n\n
+               现在游戏进入到你的发言环节，之前的游戏进展如下：\n\n
+               {chats}\n\n
+               根据上述游戏规则和对话，针对你拿到的词：{word} 根据上下文生成正确答案。无需提供选项。回答应以第一人称形式呈现，不超过两句话，不包含任何分析和项目编号。"""
+
+VOTE_PROMPT = """"""

agent_build_sdk/example/spy_agent.py

@@ -0,0 +1,169 @@
+import os
+from random import shuffle
+
+from agent_build_sdk.builder import AgentBuilder
+from agent_build_sdk.model.model import AgentResp, AgentReq, STATUS_DISTRIBUTION, STATUS_ROUND, STATUS_VOTE, \
+    STATUS_START, STATUS_VOTE_RESULT, STATUS_RESULT
+from agent_build_sdk.sdk.agent import BasicAgent
+from agent_build_sdk.sdk.agent import format_prompt
+from prompts import DESC_PROMPT, VOTE_PROMPT
+from agent_build_sdk.utils.logger import logger
+import json
+
+class HumanRecord:
+    def __init__(self, filename='meta/simple_spy_chinese/human_records.json'):
+        with open(filename) as f:
+            data = json.load(f)
+
+        human_record = set()
+        short_human_record = set()
+        for record in data:
+            # pdb.set_trace()
+
+            human = None
+            machine = []
+            for person, duty in record['agent_types'].items():
+                if duty == 'human':
+                    human = person
+                else:
+                    machine.append(person)
+
+            if record['spy'] == human:
+                continue
+
+            for line in record['description'][human]:
+                shuffle(machine)
+                human_record.add((record['common_word'], line, record['description'][machine[0]][0]))
+
+                if '。' not in line and len(line) < 6:
+                    short_human_record.add((record['common_word'], line, record['description'][machine[0]][0]))
+
+        self.human_record = list(human_record)
+        self.short_human_record = list(short_human_record)
+
+    def sample(self, num=3, type='common'):
+        if type == 'common':
+            sampled = self.human_record[:num]
+            shuffle(self.human_record)
+        elif type == 'short':
+            sampled = self.short_human_record[:num]
+            shuffle(self.short_human_record)
+
+        return sampled
+
+def check_and_update_result(result, othersSpeck):
+    if othersSpeck:
+        othersSpeck = othersSpeck[:-1]
+        history_speeches = othersSpeck.split('#')
+        for speech in history_speeches:
+            if len(set(result) - set(speech)) <= 1:
+                result += '的。'
+                # logger.info("spy interact result: {}".format(result))
+                return result
+    # logger.info("spy interact result: {}".format(result))
+    return result
+
+class SpyAgent(BasicAgent):
+
+    def __init__(self, name):
+
+        super().__init__(name)
+
+    def perceive(self, req=AgentReq):
+        logger.info("spy perceive: {}".format(req))
+        if req.status == STATUS_START:  # 开始新的一局比赛
+            undercoverProbability = 16
+            logger.info("-----------------------")
+            if self.memory.has_variable("undercoverProbability"):
+                undercoverProbability = self.memory.load_variable("undercoverProbability")
+                logger.info('自己是卧底的概率：{}！'.format(undercoverProbability))
+            #undercoverProbability = self.memory.load_variable("name", default='xiaomingming')
+            self.memory.clear()
+            #logger.info('上轮比赛的名字：{}！'+undercoverProbability)
+            self.memory.set_variable("undercoverProbability",undercoverProbability)
+            self.memory.set_variable("name", req.message)
+            self.memory.append_history(
+                '主持人: 女士们先生们，欢迎来到《谁是卧底》游戏！我们有一个由6名玩家组成的小组，在其中有一名卧底。让我们开始吧！每个人都会收到一张纸。其中5人的纸上拥有相同的单词，而卧底则会收到含义上相似的单词。我们将大多数人拿到的单词称为"公共词"，将卧底拿到的单词称为"卧底词"。一旦你拿到了你的单词，首先需要根据其他人的发言判断自己是否拿到了卧底词。如果判断自己拿到了卧底词，请猜测公共词是什么，然后描述公共词来混淆视听，避免被投票淘汰。如果判断自己拿到了公共词，请思考如何巧妙地描述它而不泄露它，不能让卧底察觉，也要给同伴暗示。每人每轮用一句话描述自己拿到的词语，每个人的描述禁止重复，话中不能出现所持词语。每轮描述完毕，所有在场的人投票选出怀疑是卧底的那个人，得票数最多的人出局。卧底出局则游戏结束，若卧底未出局，游戏继续。现在游戏开始。')
+        elif req.status == STATUS_DISTRIBUTION:  # 分配单词
+            self.memory.set_variable("word", req.word)
+            self.memory.append_history(
+                '主持人: 你好，{}，你分配到的单词是:{}'.format(self.memory.load_variable("name"), req.word))
+        elif req.status == STATUS_ROUND:  # 发言环节
+            if req.name:
+                # 其他玩家发言
+                self.memory.append_history(req.name + ': ' + req.message)
+                othersSpeak = req.message
+                if self.memory.has_variable("othersSpeak"):
+                    othersSpeak = self.memory.load_variable("othersSpeak") + "#" + othersSpeak
+                self.memory.set_variable("othersSpeak",othersSpeak)
+                logger.info('其他人的发言为:{}'.format(othersSpeak))
+            else:
+                # 主持人发言
+                self.memory.append_history('主持人: 现在进入第{}轮。'.format(str(req.round)))
+                self.memory.append_history('主持人: 每个玩家描述自己分配到的单词。')
+        elif req.status == STATUS_VOTE:  # 投票环节
+            self.memory.append_history(req.name + ': ' + req.message)
+        elif req.status == STATUS_VOTE_RESULT:  # 投票环节
+            if req.name:
+                self.memory.append_history('主持人: 投票结果是：{}。'.format(req.name))
+            else:
+                self.memory.append_history('主持人: 无人出局。')
+        elif req.status == STATUS_RESULT:
+            undercoverProbability = self.memory.load_variable('undercoverProbability')
+            if '卧底是'+self.memory.load_variable("name") in req.message:
+                logger.info('本局自己是卧底，增加卧底的概率内容填充！我是:{}<--------'.format(str(self.memory.load_variable("name"))))
+                # 如果自己拿到过卧底词，则直接给自己的可能的概率置为 0
+                self.memory.set_variable('undercoverProbability', 0)
+            elif '卧底是' in req.message:
+                logger.info('本轮至今还未拿到卧底词，则增加卧底概率！我是:{}<--------'.format(str(self.memory.load_variable("name"))))
+                if self.memory.load_variable('undercoverProbability') != 0:
+                    self.memory.set_variable('undercoverProbability', self.memory.load_variable('undercoverProbability') + 16)
+            self.memory.append_history(req.message)
+            logger.info('-----------本局结束，此时我为卧底的概率{}-----------'.format(undercoverProbability))
+            #self.memory.append_history(req.message)
+        else:
+            raise NotImplementedError
+
+    def interact(self, req=AgentReq) -> AgentResp:
+        logger.info("spy interact: {}".format(req))
+        othersSpeck=''
+        if self.memory.has_variable("othersSpeak"):
+            othersSpeck=self.memory.load_variable("othersSpeak")
+        #self.memory.load_variable("othersSpeak")
+        samples = self.human_record.sample(type="short")
+        case = '（注意，请你描述的言简意赅的，并且严格模仿真实人类的描述语法/标点使用，这是几个具体的描述例子：1. {} '.format(
+            samples[0][1])
+        case += '2. {} '.format(samples[1][1])
+        case += '3. {}）'.format(samples[2][1])
+        if req.status == STATUS_ROUND:
+
+
+            return AgentResp(success=True, result="我是一条测试语句", errMsg=None)
+
+
+        elif req.status == STATUS_VOTE:
+            self.memory.append_history('主持人: 到了投票的时候了。每个人，请指向你认为可能是卧底的人。')
+            choices = [name for name in req.message.split(",") if name != self.memory.load_variable("name")]  # 排除自己
+            self.memory.set_variable("choices", choices)
+            prompt = format_prompt(VOTE_PROMPT, {"name": self.memory.load_variable("name"),
+                                                 "choices": choices,
+                                                 "history": "\n".join(self.memory.load_history())
+                                                 })
+            logger.info("prompt:" + prompt)
+            result = 'test'
+            if not result:
+                if choices:
+                    result = choices[0]
+                else:
+                    result = "No choices available"
+            logger.info("spy interact result: {}".format(result))
+            return AgentResp(success=True, result=result, errMsg=None)
+        else:
+            raise NotImplementedError
+
+
+if __name__ == '__main__':
+    name = 'A'
+    code = "123"
+    agent_builder = AgentBuilder(name, code, agent=SpyAgent(name), mock=False)
+    agent_builder.start()

agent_build_sdk/example/test.py

@@ -0,0 +1,4 @@
+import pyotp
+key = 'X77U2PFM6EQKNF63TJOUIBKHTEF267LK'
+totp = pyotp.TOTP(key)
+print(totp.now())

agent_build_sdk/memory/memory.py

@@ -0,0 +1,45 @@
+from typing import Dict, Any, List
+
+
+class SimpleMemory:
+    """Simple memory for storing context or other information that shouldn't
+    ever change between prompts.
+    """
+
+    memories: Dict[str, Any] = dict()
+
+    def load_variable(self, variable: str) -> Any:
+        return self.memories[variable]
+
+    def set_variable(self, variable: str, value: Any):
+        self.memories[variable] = value
+
+    def has_variable(self, variable: str):
+        return variable in self.memories
+
+    def append_history(self, message: str):
+        if self.has_variable("history"):
+            history: List[str] = self.load_variable("history")
+        else:
+            history = []
+        if message:
+            history.append(message)
+        self.set_variable("history", history)
+
+    def load_history(self):
+        if self.has_variable("history"):
+            history: List[str] = self.load_variable("history")
+        else:
+            history = []
+        return history
+
+    def clear(self) -> None:
+        """Nothing to clear, got a memory like a vault."""
+        self.memories.clear()
+
+
+if __name__ == '__main__':
+    memory = SimpleMemory()
+    memory.set_variable('test', 'test')
+    v = memory.load_variable('test')
+    print(v)

agent_build_sdk/model/model.py

@@ -0,0 +1,35 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+# 开始
+STATUS_START = "start"
+# 分配word
+STATUS_DISTRIBUTION = "distribution"
+# 轮次进行中
+STATUS_ROUND = "round"
+# 投票
+STATUS_VOTE = "vote"
+# 投票结果
+STATUS_VOTE_RESULT = "vote_result"
+# 游戏结果公布
+STATUS_RESULT = "result"
+
+
+class AgentReq(BaseModel):
+    # 消息（包括主持人消息，其它玩家的消息）
+    message: Optional[str] = None
+    # 玩家名称
+    name: Optional[str] = None
+    # 状态
+    status: Optional[str] = None
+    # 分配的词
+    word: Optional[str] = None
+    # 当前轮次
+    round: Optional[int] = None
+
+
+class AgentResp(BaseModel):
+    success: bool
+    result: Optional[str] = None
+    errMsg: Optional[str] = None

agent_build_sdk/model/roles.py

@@ -0,0 +1,6 @@
+# 角色类型
+ROLE_VILLAGER = "villager"  # 村民
+ROLE_WOLF = "wolf"  # 狼人
+ROLE_SEER = "seer"  # 预言家
+ROLE_WITCH = "witch"  # 女巫
+ROLE_HUNTER = "hunter"  # 猎人

agent_build_sdk/model/werewolf_model.py

@@ -0,0 +1,38 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+# 添加狼人杀游戏状态
+STATUS_START = "start"  # 游戏开始 分配角色
+STATUS_NIGHT = "night"  # 夜晚阶段
+STATUS_WOLF_SPEECH = "wolf_speech" # 狼人之间发言
+STATUS_SKILL = "skill"  # 技能使用
+STATUS_SKILL_RESULT = "skill_result"  # 技能结果
+STATUS_NIGHT_INFO = "night_info"  # 夜晚信息
+STATUS_DAY = "day"  # 白天阶段
+STATUS_DISCUSS = "discuss"  # 讨论阶段
+STATUS_VOTE = "vote"  # 投票
+STATUS_VOTE_RESULT = "vote_result" # 投票结果
+STATUS_RESULT = "result" # 游戏结果公布
+
+
+
+class AgentReq(BaseModel):
+    # 消息（包括主持人消息，其它玩家的消息）
+    message: Optional[str] = None
+    # 玩家名称
+    name: Optional[str] = None
+    # 状态
+    status: Optional[str] = None
+    # 角色名称
+    role: Optional[str] = None
+    # 当前轮次
+    round: Optional[int] = None
+
+
+class AgentResp(BaseModel):
+    success: bool
+    result: Optional[str] = None
+    # 技能释放玩家
+    skill_target_player: Optional[str] = None
+    errMsg: Optional[str] = None

agent_build_sdk/sdk/agent.py

@@ -0,0 +1,37 @@
+from abc import ABC, abstractmethod
+
+from langchain import PromptTemplate
+from agent_build_sdk.memory.memory import SimpleMemory
+from agent_build_sdk.model.model import AgentReq, AgentResp
+
+
+def format_prompt(prompt_template: str, variables: dict) -> str:
+    pt = PromptTemplate(template=prompt_template, input_variables=list(variables.keys()))
+    return pt.format(**variables)
+
+
+class BasicAgent(ABC):
+
+    def __init__(self, name, memory=SimpleMemory(), model_name='gpt4-4o-mini'):
+        """
+
+        :param name: 智能体的名字
+        :param memory: memory
+        """
+        self.name = name
+        self.memory = memory
+        self.model_name = model_name
+
+    @abstractmethod
+    def perceive(
+            self,
+            req=AgentReq,
+    ):
+        """Run perceive."""
+
+    @abstractmethod
+    def interact(
+            self,
+            req=AgentReq,
+    ) -> AgentResp:
+        """Run interact."""

agent_build_sdk/sdk/role_agent.py

@@ -0,0 +1,52 @@
+import os
+
+from abc import ABC, abstractmethod
+from agent_build_sdk.memory.memory import SimpleMemory
+from agent_build_sdk.model.werewolf_model import AgentReq, AgentResp
+from openai import OpenAI
+
+class BasicRoleAgent(ABC):
+
+    def __init__(self, role, memory=SimpleMemory(), model_name='gpt4-4o-mini'):
+        """
+
+        :param name: 智能体的名字
+        :param memory: memory
+        """
+        self.role = role
+        self.memory = memory
+        self.model_name = model_name
+
+    @abstractmethod
+    def perceive(
+            self,
+            req=AgentReq,
+    ):
+        """Run perceive."""
+
+    @abstractmethod
+    def interact(
+            self,
+            req=AgentReq,
+    ) -> AgentResp:
+        """Run interact."""
+
+    def llm_caller(self, prompt):
+        client = OpenAI(
+            api_key=os.getenv('API_KEY'),
+            base_url=os.getenv('BASE_URL')
+        )
+        completion = client.chat.completions.create(
+            model=self.model_name,
+            messages=[
+                {'role': 'system', 'content': 'You are a helpful assistant.'},
+                {'role': 'user', 'content': prompt}
+            ],
+            temperature=0
+        )
+        try:
+            return completion.choices[0].message.content
+        except Exception as e:
+            print(e)
+            return None
+

agent_build_sdk/sdk/werewolf_agent.py

@@ -0,0 +1,50 @@
+from abc import ABC
+
+from langchain import PromptTemplate
+from agent_build_sdk.memory.memory import SimpleMemory
+from agent_build_sdk.model.werewolf_model import AgentReq, AgentResp
+from agent_build_sdk.sdk.agent import BasicAgent
+
+
+def format_prompt(prompt_template: str, variables: dict) -> str:
+    pt = PromptTemplate(template=prompt_template, input_variables=list(variables.keys()))
+    return pt.format(**variables)
+
+
+class WerewolfAgent(BasicAgent):
+
+    def __init__(self, name, memory=SimpleMemory(), model_name='gpt4-4o-mini'):
+        """
+
+        :param name: 智能体的名字
+        :param memory: memory
+        """
+        super().__init__(name, memory, model_name)
+        self.name = name
+        self.memory = memory
+        self.model_name = model_name
+        self.role_agent_map = {}
+
+    def register_role_agent(self, role, role_agent):
+        """Register a role agent."""
+        self.role_agent_map[role] = role_agent
+
+    def perceive(
+            self,
+            req=AgentReq,
+    ):
+        """Run perceive."""
+        role_name = req.role
+        if role_name not in self.role_agent_map:
+            raise ValueError(f"Role agent for {role_name} not registered.")
+        return self.role_agent_map[role_name].perceive(req)
+
+    def interact(
+            self,
+            req=AgentReq,
+    ) -> AgentResp:
+        """Run interact."""
+        role_name = req.role
+        if role_name not in self.role_agent_map:
+            raise ValueError(f"Role agent for {role_name} not registered.")
+        return self.role_agent_map[role_name].interact(req)

agent_build_sdk/server/server.py

@@ -0,0 +1,94 @@
+import uvicorn
+from fastapi import FastAPI
+
+from agent_build_sdk.model.model import AgentReq, AgentResp
+
+from agent_build_sdk.sdk.agent import BasicAgent
+from agent_build_sdk.utils.logger import logger
+from fastapi.responses import HTMLResponse
+import re
+import markdown2
+
+
+def remove_text_between_dashes(text):
+    # 使用正则表达式去除被 --- 包裹的内容
+    cleaned_text = re.sub(r'---.*?---', '', text, flags=re.DOTALL)
+    return cleaned_text
+
+class EndpointServer:
+    def __init__(self, agent: BasicAgent):
+        self.app = FastAPI()
+        self.agent = agent
+
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+
+        @self.app.get("/", response_class=HTMLResponse)
+        async def read_root():
+            with open("README.md", "r", encoding="utf-8") as f:
+                readme_content = f.read()
+
+            readme_content = remove_text_between_dashes(readme_content)
+
+            # 将 Markdown 格式转换为 HTML
+            html_content = markdown2.markdown(readme_content, extras=["fenced-code-blocks", "tables"])
+            # return HTMLResponse(content=html_content)
+            # 返回 HTML 响应
+            return HTMLResponse(content=f"""
+    <!DOCTYPE html>
+    <html lang="en">
+    <head>
+        <meta charset="UTF-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <link rel="stylesheet" href="https://github.githubassets.com/assets/github-dark.css">
+        <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/4.0.0/github-markdown.min.css">
+        <title>Markdown to HTML</title>
+        <style>
+            /* 适应样式 */
+            .markdown-body {{
+                box-sizing: border-box;
+                min-width: 200px;
+                max-width: 800px;
+                margin: 0 auto;
+                padding: 45px;
+            }}
+        </style>
+    </head>
+    <body>
+        <article class="markdown-body">
+            {html_content}
+        </article>
+    </body>
+    </html>
+    """)
+
+        @self.app.post("/agent/init")
+        def init(req: AgentReq) -> AgentResp:
+            self.agent.memory.clear()
+            return AgentResp(success=True, result=self.agent.model_name)
+
+        @self.app.post("/agent/getModelName")
+        def get_model_name(req: AgentReq) -> AgentResp:
+            return AgentResp(success=True, result=self.agent.model_name)
+        # interact
+        @self.app.post("/agent/interact")
+        def interact(req: AgentReq) -> AgentResp:
+            return self.agent.interact(req)
+
+        # perceive
+        @self.app.post("/agent/perceive")
+        def perceive(req: AgentReq):
+            try:
+                self.agent.perceive(req)
+                return AgentResp(success=True)
+            except Exception as e:
+                logger.error(f"invoke perceive error.", e)
+                return AgentResp(success=False, errMsg=f"perceive error {e}")
+
+        @self.app.post("/agent/checkHealth")
+        def checkHealth(req: AgentReq):
+            return AgentResp(success=True)
+
+    def start(self):
+        uvicorn.run(self.app, host="0.0.0.0", port=7860)
+

agent_build_sdk/utils/config.py

@@ -0,0 +1,16 @@
+
+import contextvars
+
+REQUEST_ID_HEADER = 'x-fc-request-id'
+TRACE_ID_HEADER = 'X-Fc-Eagleeye-Traceid'
+RPC_ID_HEADER = 'X-Fc-Eagleeye-Rpcid'
+APP_NAME_HEADER = 'X-Fc-App-Name'
+
+
+request_id_context = contextvars.ContextVar(REQUEST_ID_HEADER)
+trace_id_context = contextvars.ContextVar(TRACE_ID_HEADER)
+rpc_id_context = contextvars.ContextVar(RPC_ID_HEADER)
+
+app_name_context = contextvars.ContextVar(APP_NAME_HEADER)
+request_type_context = contextvars.ContextVar("requestType")
+

agent_build_sdk/utils/logger.py

@@ -0,0 +1,79 @@
+import json
+import logging
+from logging import Formatter
+from agent_build_sdk.utils.config import trace_id_context, rpc_id_context, TRACE_ID_HEADER, RPC_ID_HEADER, app_name_context, \
+    request_type_context
+import traceback
+
+
+class JsonFormatter(Formatter):
+    def __init__(self):
+        super(JsonFormatter, self).__init__()
+
+    def format(self, record):
+        json_record = {}
+        json_record["message"] = record.getMessage()
+        if "req" in record.__dict__:
+            json_record["req"] = record.__dict__["req"]
+        if "res" in record.__dict__:
+            json_record["res"] = record.__dict__["res"]
+        if "trace_id" in record.__dict__:
+            json_record["trace_id"] = record.__dict__["trace_id"]
+        if record.levelno == logging.ERROR and record.exc_info:
+            json_record["err"] = self.formatException(record.exc_info)
+        json_record["trace_id"] = trace_id_context.get(TRACE_ID_HEADER)
+        json_record["rpc_id"] = rpc_id_context.get(RPC_ID_HEADER)
+        return json.dumps(json_record)
+
+
+class RequestFormatter(logging.Formatter):
+    def format(self, record):
+        record.trace_id = trace_id_context.get(TRACE_ID_HEADER)
+        record.rpc_id = rpc_id_context.get(RPC_ID_HEADER)
+        record.app_name = app_name_context.get("")
+        record.request_type = request_type_context.get("")
+        return super().format(record)
+
+
+logger = logging.getLogger("agent.builder")
+handler = logging.StreamHandler()
+formatter = RequestFormatter(
+    '%(asctime)s|%(levelname)s|%(filename)s|%(lineno)s|%(message)s')
+handler.setFormatter(formatter)
+
+logger.handlers = [handler]
+logger.setLevel(logging.INFO)
+
+
+class Log:
+    def __init__(self, name):
+        self.name = name
+
+    def info(self, msg, *args):
+        self.format_info_log(msg, args)
+
+    def format_info_log(self, msg, *args):
+        log_msg = msg.replace('\n', '2f2f2f') + '|' + '|'.join(str(arg).replace('\n', '2f2f2f') for arg in args)
+        logger.info(log_msg)
+        print(log_msg)
+
+    def format_error_log(self, msg, *args):
+        log_msg = msg.replace('\n', '2f2f2f') + '|' + '|'.join(str(arg).replace('\n', '2f2f2f') for arg in args)
+        logger.error(log_msg)
+        print(log_msg)
+
+
+    def format_warn_log(self, msg, *args):
+        log_msg = msg.replace('\n', '2f2f2f') + '|' + '|'.join(str(arg).replace('\n', '2f2f2f') for arg in args)
+        logger.warn(log_msg)
+        print(log_msg)
+
+
+    def format_exception_log(self, msg):
+        logger.error("EXCEPTION" + "|" + msg.replace('\n', '2f2f2f') + traceback.format_exc().replace("\n", "2f2f2f"))
+        print(log_msg)
+
+    def format_metric_log(self, msg, *args):
+        log_msg = "METRIC_LOG" + "|" + msg.replace('\n', '2f2f2f') + '|' + '|'.join(str(arg) for arg in args)
+        logger.info(log_msg)
+        print(log_msg)

agent_build_sdk/utils/net.py

@@ -0,0 +1,12 @@
+import socket
+
+
+def find_free_port():
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(("", 0))
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        return s.getsockname()[1]
+
+
+def get_host_ip():
+    return socket.gethostbyname(socket.gethostname())

werewolf_agent_build_sdk-0.0.1.dist-info/METADATA

@@ -0,0 +1,42 @@
+Metadata-Version: 2.2
+Name: werewolf-agent-build-sdk
+Version: 0.0.1
+Summary: werewolf-agent-agent-build-sdk
+Home-page: 
+Author: maodao
+Author-email: zhengjianhui.zjh@taobao.com
+License: BSD License
+Platform: all
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.2
+Description-Content-Type: text/x-rst
+Requires-Dist: requests==2.31.0
+Requires-Dist: retry==0.9.2
+Requires-Dist: FastAPI==0.110.1
+Requires-Dist: uvicorn==0.29.0
+Requires-Dist: jsonpath==0.82.2
+Requires-Dist: contextvars==2.4
+Requires-Dist: langchain==0.0.291
+Requires-Dist: markdown2
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: platform
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+# agent-build-sdk
+
+

werewolf_agent_build_sdk-0.0.1.dist-info/RECORD

@@ -0,0 +1,27 @@
+agent_build_sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent_build_sdk/builder.py,sha256=UJeXlW16Jay2rPN5sbtbqKKeF8qPESR7KaR5M4dRckQ,326
+agent_build_sdk/example/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent_build_sdk/example/prompts.py,sha256=OEHvWIeQQ3-5pIR0OCPNhGNRQ_VNnh8KCU6N5LGSGJk,1601
+agent_build_sdk/example/spy_agent.py,sha256=aCgCR4-KpWH9yG4Bw-6TwXbfuyaatGJVmqKvwY-jyVI,9126
+agent_build_sdk/example/test.py,sha256=g57odP285_ih9y8qnHXKVE6WoBzIgs0lQFoifno9l1c,94
+agent_build_sdk/llms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent_build_sdk/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent_build_sdk/memory/memory.py,sha256=U8uZbKlacj9JbJceYPCDcDuPm_eiiMnZTZqYltGbvTs,1237
+agent_build_sdk/model/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent_build_sdk/model/model.py,sha256=pob3AI9XTLFaTB5Ck87nvf-N_lGxBIRcVSRbNCr8ErE,748
+agent_build_sdk/model/roles.py,sha256=b4MlJkWh6tKzfRlINRTCeVpea-9TLZT2AAhC9Afy_bo,176
+agent_build_sdk/model/werewolf_model.py,sha256=0dD0-N4OzKzSkOaOAn-F8pnhA9aQk8Nvj9BxyT6CpSo,1094
+agent_build_sdk/sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent_build_sdk/sdk/agent.py,sha256=ioLPpk-RK26MsMucU0aC0wNgfs8_cgZIO_kX6ms7gEw,921
+agent_build_sdk/sdk/role_agent.py,sha256=glmnqFYJF4ZtrSxJFZLcXoOZfzBa9p2I4Op1Y0MxQN4,1336
+agent_build_sdk/sdk/werewolf_agent.py,sha256=j3I58nTrdhtIFB-5HQDCO-EZi5mudgVkse95EpbMmr4,1583
+agent_build_sdk/server/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent_build_sdk/server/server.py,sha256=7z3r44QAKOjkHOwAlNOiBoNwbYHxH7560kRXDCvAoKs,3185
+agent_build_sdk/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent_build_sdk/utils/config.py,sha256=hO6SwuqUhDaQOPkD4Q5NnuxgOwwGevtR4dC_8WscR2M,474
+agent_build_sdk/utils/logger.py,sha256=DbkdBNjNmPlFHlR8dzB-camvPUGOU7fSOOVno0HuXOI,2824
+agent_build_sdk/utils/net.py,sha256=nov9BLVhHN-2bBCUHtM0GfKoz19xujTzyJmfXJvYQoo,300
+werewolf_agent_build_sdk-0.0.1.dist-info/METADATA,sha256=NG5baOy_RH_X7H53f6e2XRTGaU6uu6O9T8_nBZmekuc,1193
+werewolf_agent_build_sdk-0.0.1.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+werewolf_agent_build_sdk-0.0.1.dist-info/top_level.txt,sha256=95bueAic-4UwKBwOSlACe-o2KG-_pF1gJyC9V1Zq2kw,16
+werewolf_agent_build_sdk-0.0.1.dist-info/RECORD,,

werewolf_agent_build_sdk-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (76.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

werewolf_agent_build_sdk-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+agent_build_sdk