pycityagent 2.0.0a10__tar.gz → 2.0.0a12__tar.gz

{pycityagent-2.0.0a10 → pycityagent-2.0.0a12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pycityagent
-Version: 2.0.0a10
+Version: 2.0.0a12
 Summary: LLM-based城市环境agent构建库
 License: MIT
 Author: Yuwei Yan

{pycityagent-2.0.0a10 → pycityagent-2.0.0a12}/pycityagent/agent.py

@@ -2,12 +2,15 @@
 
 from abc import ABC, abstractmethod
 import asyncio
+import json
 from uuid import UUID
 from copy import deepcopy
 from datetime import datetime
+import time
 from enum import Enum
 import logging
 import random
+import uuid
 from typing import Dict, List, Optional
 
 from pycityagent.environment.sim.person_service import PersonService
@@ -64,6 +67,7 @@ class Agent(ABC):
         """
         self._name = name
         self._type = type
+        self._uuid = uuid.uuid4()
         self._llm_client = llm_client
         self._economy_client = economy_client
         self._messager = messager
@@ -118,76 +122,15 @@ class Agent(ABC):
         """
         self._exp_id = exp_id
 
-    async def _bind_to_simulator(self):
-        """
-        Bind Agent to Simulator
-
-        Args:
-            person_template (dict, optional): The person template in dict format. Defaults to PersonService.default_dict_person().
-        """
-        if self._simulator is None:
-            logging.warning("Simulator is not set")
-            return
-        if not self._has_bound_to_simulator:
-            FROM_MEMORY_KEYS = {
-                "attribute",
-                "home",
-                "work",
-                "vehicle_attribute",
-                "bus_attribute",
-                "pedestrian_attribute",
-                "bike_attribute",
-            }
-            simulator = self._simulator
-            memory = self.memory
-            person_id = await memory.get("id")
-            # ATTENTION:模拟器分配的id从0开始
-            if person_id >= 0:
-                await simulator.get_person(person_id)
-                logging.debug(f"Binding to Person `{person_id}` already in Simulator")
-            else:
-                dict_person = deepcopy(self._person_template)
-                for _key in FROM_MEMORY_KEYS:
-                    try:
-                        _value = await memory.get(_key)
-                        if _value:
-                            dict_person[_key] = _value
-                    except KeyError as e:
-                        continue
-                resp = await simulator.add_person(
-                    dict2pb(dict_person, person_pb2.Person())
-                )
-                person_id = resp["person_id"]
-                await memory.update("id", person_id, protect_llm_read_only_fields=False)
-                logging.debug(
-                    f"Binding to Person `{person_id}` just added to Simulator"
-                )
-                # 防止模拟器还没有到prepare阶段导致get_person出错
-            self._has_bound_to_simulator = True
-            self._agent_id = person_id
+    @property
+    def uuid(self):
+        """The Agent's UUID"""
+        return self._uuid
 
-    async def _bind_to_economy(self):
-        if self._economy_client is None:
-            logging.warning("Economy client is not set")
-            return
-        if not self._has_bound_to_economy:
-            if self._has_bound_to_simulator:
-                try:
-                    await self._economy_client.remove_agents([self._agent_id])
-                except:
-                    pass
-                person_id = await self.memory.get("id")
-                await self._economy_client.add_agents(
-                    {
-                        "id": person_id,
-                        "currency": await self.memory.get("currency"),
-                    }
-                )
-                self._has_bound_to_economy = True
-            else:
-                logging.debug(
-                    f"Binding to Economy before binding to Simulator, skip binding to Economy Simulator"
-                )
+    @property
+    def sim_id(self):
+        """The Agent's Simulator ID"""
+        return self._agent_id
 
     @property
     def llm(self):
@@ -277,22 +220,60 @@ class Agent(ABC):
         """获取采访历史记录"""
         return self._interview_history
 
-    async def handle_message(self, payload: str):
+    async def handle_agent_chat_message(self, payload: dict):
+        """处理收到的消息，识别发送者"""
+        # 从消息中解析发送者 ID 和消息内容
+        print(
+            f"Agent {self._uuid} received agent chat message: '{payload['content']}' from Agent {payload['from']}"
+        )
+
+    async def handle_user_chat_message(self, payload: dict):
+        """处理收到的消息，识别发送者"""
+        # 从消息中解析发送者 ID 和消息内容
+        print(
+            f"Agent {self._uuid} received user chat message: '{payload['content']}' from User"
+        )
+
+    async def handle_user_survey_message(self, payload: dict):
         """处理收到的消息，识别发送者"""
         # 从消息中解析发送者 ID 和消息内容
-        message, sender_id = payload.split("|from:")
         print(
-            f"Agent {self._agent_id} received message: '{message}' from Agent {sender_id}"
+            f"Agent {self._uuid} received user survey message: '{payload['content']}' from User"
         )
 
-    async def send_message(
-        self, to_agent_id: int, message: str, sub_topic: str = "chat"
+    async def _send_message(
+        self, to_agent_uuid: UUID, payload: dict, sub_topic: str
     ):
-        """通过 Messager 发送消息，附带发送者的 ID"""
+        """通过 Messager 发送消息"""
         if self._messager is None:
             raise RuntimeError("Messager is not set")
-        topic = f"/exps/{self._exp_id}/agents/{to_agent_id}/{sub_topic}"
-        await self._messager.send_message(topic, message, self._agent_id)
+        topic = f"exps/{self._exp_id}/agents/{to_agent_uuid}/{sub_topic}"
+        await self._messager.send_message(topic, payload)
+
+    async def send_message_to_agent(
+        self, to_agent_uuid: UUID, content: dict
+    ):
+        """通过 Messager 发送消息"""
+        if self._messager is None:
+            raise RuntimeError("Messager is not set")
+        payload = {
+            "from": self._uuid,
+            "content": content,
+            "timestamp": int(time.time()),
+            "day": await self._simulator.get_simulator_day(),
+            "t": await self._simulator.get_simulator_second_from_start_of_day(),
+        }
+        await self._send_message(to_agent_uuid, payload, "agent-chat")
+
+    async def send_message_to_user(
+        self, content: dict
+    ):
+        pass
+
+    async def send_message_to_survey(
+        self, content: dict
+    ):
+        pass
 
     @abstractmethod
     async def forward(self) -> None:
@@ -410,12 +391,17 @@ class CitizenAgent(Agent):
                     f"Binding to Economy before binding to Simulator, skip binding to Economy Simulator"
                 )
 
-    async def handle_gather_message(self, payload: str):
+    async def handle_gather_message(self, payload: dict):
         """处理收到的消息，识别发送者"""
         # 从消息中解析发送者 ID 和消息内容
-        target, sender_id = payload.split("|from:")
+        target = payload["target"]
+        sender_id = payload["from"]
         content = await self.memory.get(f"{target}")
-        await self.send_message(int(sender_id), content, "gather")
+        payload = {
+            "from": self._uuid,
+            "content": content,
+        }
+        await self._send_message(sender_id, payload, "gather")
 
 
 class InstitutionAgent(Agent):
@@ -455,28 +441,60 @@ class InstitutionAgent(Agent):
             self._agent_id = _id
             await self._memory.update("id", _id, protect_llm_read_only_fields=False)
             try:
-                await self._economy_client.remove_agents([self._agent_id])
+                await self._economy_client.remove_orgs([self._agent_id])
             except:
                 pass
             try:
                 id = await self._memory.get("id")
                 type = await self._memory.get("type")
-                nominal_gdp = await self._memory.get("nominal_gdp")
-                real_gdp = await self._memory.get("real_gdp")
-                unemployment = await self._memory.get("unemployment")
-                wages = await self._memory.get("wages")
-                prices = await self._memory.get("prices")
-                inventory = await self._memory.get("inventory")
-                price = await self._memory.get("price")
-                currency = await self._memory.get("currency")
-                interest_rate = await self._memory.get("interest_rate")
-                bracket_cutoffs = await self._memory.get("bracket_cutoffs")
-                bracket_rates = await self._memory.get("bracket_rates")
+                try:
+                    nominal_gdp = await self._memory.get("nominal_gdp")
+                except:
+                    nominal_gdp = []
+                try:
+                    real_gdp = await self._memory.get("real_gdp")
+                except:
+                    real_gdp = []
+                try:
+                    unemployment = await self._memory.get("unemployment")
+                except:
+                    unemployment = []
+                try:
+                    wages = await self._memory.get("wages")
+                except:
+                    wages = []
+                try:
+                    prices = await self._memory.get("prices")
+                except:
+                    prices = []
+                try:
+                    inventory = await self._memory.get("inventory")
+                except:
+                    inventory = 0
+                try:
+                    price = await self._memory.get("price")
+                except:
+                    price = 0
+                try:
+                    currency = await self._memory.get("currency")
+                except:
+                    currency = 0.0
+                try:
+                    interest_rate = await self._memory.get("interest_rate")
+                except:
+                    interest_rate = 0.0
+                try:
+                    bracket_cutoffs = await self._memory.get("bracket_cutoffs")
+                except:
+                    bracket_cutoffs = []
+                try:
+                    bracket_rates = await self._memory.get("bracket_rates")
+                except:
+                    bracket_rates = []
                 await self._economy_client.add_orgs(
                     {
                         "id": id,
                         "type": type,
-                        "currency": currency,
                         "nominal_gdp": nominal_gdp,
                         "real_gdp": real_gdp,
                         "unemployment": unemployment,
@@ -484,6 +502,7 @@ class InstitutionAgent(Agent):
                         "prices": prices,
                         "inventory": inventory,
                         "price": price,
+                        "currency": currency,
                         "interest_rate": interest_rate,
                         "bracket_cutoffs": bracket_cutoffs,
                         "bracket_rates": bracket_rates,
@@ -493,15 +512,20 @@ class InstitutionAgent(Agent):
                 logging.error(f"Failed to bind to Economy: {e}")
             self._has_bound_to_economy = True
 
-    async def handle_gather_message(self, payload: str):
+    async def handle_gather_message(self, payload: dict):
         """处理收到的消息，识别发送者"""
         # 从消息中解析发送者 ID 和消息内容
-        content, sender_id = payload.split("|from:")
+        content = payload["content"]
+        sender_id = payload["from"]
         print(
-            f"Agent {self._agent_id} received gather message: '{content}' from Agent {sender_id}"
+            f"Agent {self._uuid} received gather message: '{content}' from Agent {sender_id}"
         )
 
-    async def gather_messages(self, agent_ids: list[int], content: str):
+    async def gather_messages(self, agent_ids: list[UUID], target: str):
         """从多个智能体收集消息"""
+        payload = {
+            "from": self._uuid,
+            "target": target,
+        }
         for agent_id in agent_ids:
-            await self.send_message(agent_id, content, "gather")
+            await self._send_message(agent_id, payload, "gather")

{pycityagent-2.0.0a10 → pycityagent-2.0.0a12}/pycityagent/environment/simulator.py

@@ -190,7 +190,25 @@ class Simulator:
             formatted_time = current_time.strftime(format)
             return formatted_time
         else:
+            # BUG: 返回的time是float类型
             return t_sec["t"]
+        
+    async def get_simulator_day(self) -> int:
+        """
+        获取模拟器到第几日
+        """
+        t_sec = await self._client.clock_service.Now({})
+        t_sec = cast(dict[str, int], t_sec)
+        day = t_sec["t"] // 86400
+        return day
+    
+    async def get_simulator_second_from_start_of_day(self) -> int:
+        """
+        获取模拟器从00:00:00到当前的秒数
+        """
+        t_sec = await self._client.clock_service.Now({})
+        t_sec = cast(dict[str, int], t_sec)
+        return t_sec["t"] % 86400
 
     async def get_person(self, person_id: int) -> dict:
         return await self._client.person_service.GetPerson(

{pycityagent-2.0.0a10 → pycityagent-2.0.0a12}/pycityagent/message/messager.py

@@ -1,5 +1,6 @@
 import asyncio
 from collections import defaultdict
+import json
 import logging
 import math
 from aiomqtt import Client
@@ -42,7 +43,7 @@ class Messager:
             return
         await self.client.subscribe(topic)
         self.subscribers[topic] = agent
-        logging.info(f"Subscribed to {topic} for Agent {agent._agent_id}")
+        logging.info(f"Subscribed to {topic} for Agent {agent._uuid}")
 
     async def receive_messages(self):
         """监听并将消息存入队列"""
@@ -56,10 +57,9 @@ class Messager:
             messages.append(await self.message_queue.get())
         return messages
 
-    async def send_message(self, topic: str, payload: str, sender_id: int):
-        """通过 Messager 发送消息，包含发送者 ID"""
-        # 构造消息，payload 中加入 sender_id 以便接收者识别
-        message = f"{payload}|from:{sender_id}"
+    async def send_message(self, topic: str, payload: dict):
+        """通过 Messager 发送消息"""
+        message = json.dumps(payload, default=str)
         await self.client.publish(topic, message)
         logging.info(f"Message sent to {topic}: {message}")
 

{pycityagent-2.0.0a10 → pycityagent-2.0.0a12}/pycityagent/simulation/agentgroup.py

@@ -1,5 +1,7 @@
 import asyncio
+import json
 import logging
+import uuid
 import ray
 from uuid import UUID
 from pycityagent.agent import Agent
@@ -16,6 +18,7 @@ class AgentGroup:
         self.agents = agents
         self.config = config
         self.exp_id = exp_id
+        self._uuid = uuid.uuid4()
         self.messager = Messager(
             hostname=config["simulator_request"]["mqtt"]["server"],
             port=config["simulator_request"]["mqtt"]["port"],
@@ -53,26 +56,30 @@ class AgentGroup:
     async def init_agents(self):
         for agent in self.agents:
             await agent.bind_to_simulator()
-        self.id2agent = {agent._agent_id: agent for agent in self.agents}
+        self.id2agent = {agent._uuid: agent for agent in self.agents}
         await self.messager.connect()
         if self.messager.is_connected():
             await self.messager.start_listening()
             for agent in self.agents:
                 agent.set_messager(self.messager)
-                topic = f"/exps/{self.exp_id}/agents/{agent._agent_id}/chat"
+                topic = f"exps/{self.exp_id}/agents/{agent._uuid}/agent-chat"
                 await self.messager.subscribe(topic, agent)
-                topic = f"/exps/{self.exp_id}/agents/{agent._agent_id}/gather"
+                topic = f"exps/{self.exp_id}/agents/{agent._uuid}/user-chat"
+                await self.messager.subscribe(topic, agent)
+                topic = f"exps/{self.exp_id}/agents/{agent._uuid}/user-survey"
+                await self.messager.subscribe(topic, agent)
+                topic = f"exps/{self.exp_id}/agents/{agent._uuid}/gather"
                 await self.messager.subscribe(topic, agent)
         self.initialized = True
 
     async def gather(self, content: str):
         results = {}
         for agent in self.agents:
-            results[agent._agent_id] = await agent.memory.get(content)
+            results[agent._uuid] = await agent.memory.get(content)
         return results
 
-    async def update(self, target_agent_id: str, target_key: str, content: Any):
-        agent = self.id2agent[target_agent_id]
+    async def update(self, target_agent_uuid: str, target_key: str, content: Any):
+        agent = self.id2agent[target_agent_uuid]
         await agent.memory.update(target_key, content)
 
     async def step(self):
@@ -90,7 +97,7 @@ class AgentGroup:
         # Step 2: 从 Messager 获取消息
         messages = await self.messager.fetch_messages()
 
-        print(f"Received {len(messages)} messages")
+        logging.info(f"Group {self._uuid} received {len(messages)} messages")
 
         # Step 3: 分发消息到对应的 Agent
         for message in messages:
@@ -100,15 +107,20 @@ class AgentGroup:
             # 添加解码步骤，将bytes转换为str
             if isinstance(payload, bytes):
                 payload = payload.decode("utf-8")
-
-            # 提取 agent_id（主题格式为 "/exps/{exp_id}/agents/{agent_id}/chat" 或 "/exps/{exp_id}/agents/{agent_id}/gather"）
-            _, _, _, agent_id, topic_type = topic.strip("/").split("/")
-            agent_id = int(agent_id)
-
-            if agent_id in self.id2agent:
-                agent = self.id2agent[agent_id]
-                if topic_type == "chat":
-                    await agent.handle_message(payload)
+                payload = json.loads(payload)
+
+            # 提取 agent_id（主题格式为 "exps/{exp_id}/agents/{agent_uuid}/{topic_type}"）
+            _, _, _, agent_uuid, topic_type = topic.strip("/").split("/")
+                
+            if uuid.UUID(agent_uuid) in self.id2agent:
+                agent = self.id2agent[uuid.UUID(agent_uuid)]
+                # topic_type: agent-chat, user-chat, user-survey, gather
+                if topic_type == "agent-chat":
+                    await agent.handle_agent_chat_message(payload)
+                elif topic_type == "user-chat":
+                    await agent.handle_user_chat_message(payload)
+                elif topic_type == "user-survey":
+                    await agent.handle_user_survey_message(payload)
                 elif topic_type == "gather":
                     await agent.handle_gather_message(payload)
 
@@ -125,13 +137,13 @@ class AgentGroup:
         try:
             # 获取开始时间
             start_time = await self.simulator.get_time()
-            assert type(start_time)==int
+            start_time = int(start_time)
             # 计算结束时间（秒）
             end_time = start_time + day * 24 * 3600  # 将天数转换为秒
 
             while True:
                 current_time = await self.simulator.get_time()
-                assert type(current_time)==int
+                current_time = int(current_time)
                 if current_time >= end_time:
                     break
                 await self.step()

{pycityagent-2.0.0a10 → pycityagent-2.0.0a12}/pycityagent/simulation/simulation.py

@@ -6,10 +6,10 @@ from datetime import datetime
 import random
 from typing import Dict, List, Optional, Callable, Union,Any
 from mosstool.map._map_util.const import AOI_START_ID
-
+import pycityproto.city.economy.v2.economy_pb2 as economyv2
 from pycityagent.memory.memory import Memory
 
-from ..agent import Agent
+from ..agent import Agent, InstitutionAgent
 from .interview import InterviewManager
 from .survey import QuestionType, SurveyManager
 from .ui import InterviewUI
@@ -40,18 +40,30 @@ class AgentSimulation:
             self.agent_class = [agent_class]
         self.config = config
         self.agent_prefix = agent_prefix
-        self._agents: Dict[str, Agent] = {}
-        self._groups: Dict[str, AgentGroup] = {} # type:ignore
-        self._interview_manager = InterviewManager()
-        self._interview_lock = asyncio.Lock()
-        self._start_time = datetime.now()
-        self._agent_run_times: Dict[str, datetime] = {}  # 记录每个智能体的运行开始时间
-        self._ui: Optional[InterviewUI] = None
+        self._agents: Dict[uuid.UUID, Agent] = {}
+        self._groups: Dict[str, AgentGroup] = {}
+        self._agent_uuid2group: Dict[uuid.UUID, AgentGroup] = {}
+        self._agent_uuids: List[uuid.UUID] = []
+
         self._loop = asyncio.get_event_loop()
-        self._blocked_agents: List[str] = []  # 新增：持续阻塞的智能体列表
+        self._interview_manager = InterviewManager()
         self._survey_manager = SurveyManager()
-        self._agentid2group: Dict[str, AgentGroup] = {}# type:ignore
-        self._agent_ids: List[str] = []
+
+    @property
+    def agents(self):
+        return self._agents
+    
+    @property
+    def groups(self):
+        return self._groups
+    
+    @property
+    def agent_uuids(self):
+        return self._agent_uuids
+    
+    @property
+    def agent_uuid2group(self):
+        return self._agent_uuid2group
 
     async def init_agents(
         self,
@@ -76,15 +88,25 @@ class AgentSimulation:
             logging.warning(
                 "memory_config_func is None, using default memory config function"
             )
-            memory_config_func = [self.default_memory_config_func]
+            memory_config_func = []
+            for agent_class in self.agent_class:
+                if issubclass(agent_class, InstitutionAgent):
+                    memory_config_func.append(self.default_memory_config_institution)
+                else:
+                    memory_config_func.append(self.default_memory_config_citizen)
         elif not isinstance(memory_config_func, list):
             memory_config_func = [memory_config_func]
 
         if len(memory_config_func) != len(agent_count):
             logging.warning(
-                "memory_config_func和agent_count的长度不一致，使用默认的memory_config_func"
+                "memory_config_func和agent_count的长度不一致，使用默认的memory_config"
             )
-            memory_config_func = [self.default_memory_config_func] * len(agent_count)
+            memory_config_func = []
+            for agent_class in self.agent_class:
+                if agent_class == InstitutionAgent:
+                    memory_config_func.append(self.default_memory_config_institution)
+                else:
+                    memory_config_func.append(self.default_memory_config_citizen)
 
         class_init_index = 0
         for i in range(len(self.agent_class)):
@@ -97,7 +119,7 @@ class AgentSimulation:
                 # 获取Memory配置
                 extra_attributes, profile, base = memory_config_func_i()
                 memory = Memory(
-                    config=extra_attributes, profile=profile.copy(), base=base.copy()
+                    config=extra_attributes, profile=profile, base=base
                 )
 
                 # 创建智能体时传入Memory配置
@@ -106,7 +128,8 @@ class AgentSimulation:
                     memory=memory,
                 )
 
-                self._agents[agent_name] = agent
+                self._agents[agent._uuid] = agent
+                self._agent_uuids.append(agent._uuid)
 
             # 计算需要的组数,向上取整以处理不足一组的情况
             num_group = (agent_count_i + group_size - 1) // group_size
@@ -121,9 +144,11 @@ class AgentSimulation:
 
                 # 获取当前组的agents
                 agents = list(self._agents.values())[start_idx:end_idx]
-                group_name = f"{self.agent_prefix}_{i}_group_{k}"
+                group_name = f"AgentType_{i}_Group_{k}"
                 group = AgentGroup.remote(agents, self.config, self.exp_id)
                 self._groups[group_name] = group
+                for agent in agents:
+                    self._agent_uuid2group[agent._uuid] = group
 
             class_init_index += agent_count_i  # 更新类初始索引
 
@@ -132,12 +157,6 @@ class AgentSimulation:
             init_tasks.append(group.init_agents.remote())
         await asyncio.gather(*init_tasks)
 
-        for group in self._groups.values():
-            agent_ids = await group.gather.remote("id")
-            for agent_id in agent_ids:
-                self._agent_ids.append(agent_id)
-                self._agentid2group[agent_id] = group
-
     async def gather(self, content: str):
         """收集智能体的特定信息"""
         gather_tasks = []
@@ -147,10 +166,29 @@ class AgentSimulation:
 
     async def update(self, target_agent_id: str, target_key: str, content: Any):
         """更新指定智能体的记忆"""
-        group = self._agentid2group[target_agent_id]
+        group = self._agent_uuid2group[target_agent_id]
         await group.update.remote(target_agent_id, target_key, content)
 
-    def default_memory_config_func(self):
+    def default_memory_config_institution(self):
+        """默认的Memory配置函数"""
+        EXTRA_ATTRIBUTES = {
+            "type": (int, random.choice([economyv2.ORG_TYPE_BANK, economyv2.ORG_TYPE_GOVERNMENT, economyv2.ORG_TYPE_FIRM, economyv2.ORG_TYPE_NBS, economyv2.ORG_TYPE_UNSPECIFIED])),
+            "nominal_gdp": (list, [], True),
+            "real_gdp": (list, [], True),
+            "unemployment": (list, [], True),
+            "wages": (list, [], True),
+            "prices": (list, [], True),
+            "inventory": (int, 0, True),
+            "price": (float, 0.0, True),
+            "interest_rate": (float, 0.0, True),
+            "bracket_cutoffs": (list, [], True),
+            "bracket_rates": (list, [], True),
+            "employees": (list, [], True),
+            "customers": (list, [], True),
+        }
+        return EXTRA_ATTRIBUTES, None, None
+
+    def default_memory_config_citizen(self):
         """默认的Memory配置函数"""
         EXTRA_ATTRIBUTES = {
             # 需求信息
@@ -248,201 +286,6 @@ class AgentSimulation:
 
         return EXTRA_ATTRIBUTES, PROFILE, BASE
 
-    def get_agent_runtime(self, agent_name: str) -> str:
-        """获取智能体运行时间"""
-        if agent_name not in self._agent_run_times:
-            return "-"
-        delta = datetime.now() - self._agent_run_times[agent_name]
-        hours = delta.seconds // 3600
-        minutes = (delta.seconds % 3600) // 60
-        seconds = delta.seconds % 60
-        return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
-
-    def get_total_runtime(self) -> str:
-        """获取总运行时间"""
-        delta = datetime.now() - self._start_time
-        hours = delta.seconds // 3600
-        minutes = (delta.seconds % 3600) // 60
-        seconds = delta.seconds % 60
-        return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
-
-    def export_chat_history(self, agent_name: str | None) -> str:
-        """导出对话历史
-
-        Args:
-            agent_name: 可选的智能体名称，如果提供则只导出该智能体的对话
-
-        Returns:
-            str: JSON格式的对话历史
-        """
-        history = (
-            self._interview_manager.get_agent_history(agent_name)
-            if agent_name
-            else self._interview_manager.get_recent_history(limit=1000)
-        )
-
-        # 转换为易读格式
-        formatted_history = []
-        for record in history:
-            formatted_history.append(
-                {
-                    "timestamp": record.timestamp.strftime("%Y-%m-%d %H:%M:%S"),
-                    "agent": record.agent_name,
-                    "question": record.question,
-                    "response": record.response,
-                    "blocking": record.blocking,
-                }
-            )
-
-        return json.dumps(formatted_history, ensure_ascii=False, indent=2)
-
-    def toggle_agent_block(self, agent_name: str, blocking: bool) -> str:
-        """切换智能体的阻塞状态
-
-        Args:
-            agent_name: 能体名称
-            blocking: True表示阻塞，False表示取消阻塞
-
-        Returns:
-            str: 状态变更消息
-        """
-        if agent_name not in self._agents:
-            return f"找不到智能体 {agent_name}"
-
-        if blocking and agent_name not in self._blocked_agents:
-            self._blocked_agents.append(agent_name)
-            self._agents[agent_name]._blocked = True
-            return f"已阻塞智能体 {agent_name}"
-        elif not blocking and agent_name in self._blocked_agents:
-            self._blocked_agents.remove(agent_name)
-            self._agents[agent_name]._blocked = False
-            return f"已取消阻塞智能体 {agent_name}"
-
-        return f"智能体 {agent_name} 状态未变"
-
-    async def interview_agent(self, agent_name: str, question: str) -> str:
-        """采访指定智能体"""
-        agent = self._agents.get(agent_name)
-        if not agent:
-            return "找不到指定的智能体"
-
-        try:
-            response = await agent.generate_response(question)
-            # 记录采访历史
-            self._interview_manager.add_record(
-                agent_name,
-                question,
-                response,
-                blocking=(agent_name in self._blocked_agents),
-            )
-            return response
-
-        except Exception as e:
-            logger.error(f"采访过程出错: {str(e)}")
-            return f"采访过程出现错误: {str(e)}"
-
-    async def submit_survey(self, agent_name: str, survey_id: str) -> str:
-        """向智能体提交问卷
-
-        Args:
-            agent_name: 智能体名称
-            survey_id: 问卷ID
-
-        Returns:
-            str: 处理结果
-        """
-        agent = self._agents.get(agent_name)
-        if not agent:
-            return "找不到指定的智能体"
-
-        survey = self._survey_manager.get_survey(survey_id)
-        if not survey:
-            return "找不到指定的问卷"
-
-        try:
-            # 建问卷提示
-            prompt = f"""请以第一人称回答以下调查问卷:
-
-问卷标题: {survey.title}
-问卷说明: {survey.description}
-
-"""
-            for i, question in enumerate(survey.questions):
-                prompt += f"\n问题{i+1}. {question.content}"
-                if question.type in (
-                    QuestionType.SINGLE_CHOICE,
-                    QuestionType.MULTIPLE_CHOICE,
-                ):
-                    prompt += "\n选项: " + ", ".join(question.options)
-                elif question.type == QuestionType.RATING:
-                    prompt += (
-                        f"\n(请给出{question.min_rating}-{question.max_rating}的评分)"
-                    )
-                elif question.type == QuestionType.LIKERT:
-                    prompt += "\n(1-强烈不同意, 2-不同意, 3-中立, 4-同意, 5-强烈同意)"
-
-            # 生成回答
-            response = await agent.generate_response(prompt)
-
-            # 存储原始回答
-            self._survey_manager.add_response(
-                survey_id, agent_name, {"raw_response": response, "parsed": False}
-            )
-
-            return response
-
-        except Exception as e:
-            logger.error(f"问卷处理出错: {str(e)}")
-            return f"问卷处理出现错误: {str(e)}"
-
-    def create_survey(self, **survey_data: dict) -> None:
-        """创建新问卷
-
-        Args:
-            survey_data: 问卷数据，包含 title, description, questions
-
-        Returns:
-            更新后的问卷列表
-        """
-        self._survey_manager.create_survey(**survey_data)  # type:ignore
-
-    def get_surveys(self) -> list:
-        """获取所有问卷"""
-        return self._survey_manager.get_all_surveys()
-
-    def get_survey_questions(self, survey_id: str) -> dict | None:
-        """获取指定问卷的问题列表
-
-        Args:
-            survey_id: 问卷ID
-
-        Returns:
-            问卷数据，包含 title, description, questions
-        """
-        for _, survey in self._survey_manager._surveys.items():
-            survey_dict = survey.to_dict()
-            if survey_dict["id"] == survey_id:
-                return survey_dict
-        return None
-
-    async def init_ui(
-        self,
-        server_name: str = "127.0.0.1",
-        server_port: int = 7860,
-    ):
-        """初始化UI"""
-        self._interview_lock = asyncio.Lock()
-        # 初始化GradioUI
-        self._ui = InterviewUI(self)
-        interface = self._ui.create_interface()
-        interface.queue().launch(
-            server_name=server_name,
-            server_port=server_port,
-            prevent_thread_lock=True,
-            quiet=True,
-        )
-        logger.info(f"Gradio Frontend is running on http://{server_name}:{server_port}")
-
     async def step(self):
         """运行一步, 即每个智能体执行一次forward"""
         try:

{pycityagent-2.0.0a10 → pycityagent-2.0.0a12}/pyproject.toml

@@ -3,7 +3,7 @@ in-project = true
 
 [tool.poetry]
 name = "pycityagent"
-version = "2.0.0a10"
+version = "2.0.0a12"
 description = "LLM-based城市环境agent构建库"
 authors = ["Yuwei Yan <pinkgranite86@gmail.com>","Junbo Yan <yanjb20thu@gmali.com>"]
 license = "MIT"