pycityagent 2.0.0a14__py3-none-any.whl → 2.0.0a15__py3-none-any.whl

pycityagent/__init__.py

@@ -4,5 +4,19 @@ Pycityagent: 城市智能体构建框架
 
 from .agent import Agent, CitizenAgent, InstitutionAgent
 from .environment import Simulator
+import logging
+
+# 创建一个 pycityagent 记录器
+logger = logging.getLogger("pycityagent")
+logger.setLevel(logging.WARNING)  # 默认级别
+
+# 如果没有处理器，则添加一个
+if not logger.hasHandlers():
+    handler = logging.StreamHandler()
+    formatter = logging.Formatter(
+        "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
 
 __all__ = ["Agent", "Simulator", "CitizenAgent", "InstitutionAgent"]

pycityagent/agent.py

@@ -2,11 +2,9 @@
 
 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
@@ -28,6 +26,8 @@ from .environment import Simulator
 from .llm import LLM
 from .memory import Memory
 
+logger = logging.getLogger("pycityagent")
+
 
 class AgentType(Enum):
     """
@@ -73,7 +73,7 @@ class Agent(ABC):
         """
         self._name = name
         self._type = type
-        self._uuid = uuid.uuid4()
+        self._uuid = str(uuid.uuid4())
         self._llm_client = llm_client
         self._economy_client = economy_client
         self._messager = messager
@@ -123,12 +123,18 @@ class Agent(ABC):
         """
         self._memory = memory
 
-    def set_exp_id(self, exp_id: str|UUID):
+    def set_exp_id(self, exp_id: str):
         """
         Set the exp_id of the agent.
         """
         self._exp_id = exp_id
 
+    def set_avro_file(self, avro_file: Dict[str, str]):
+        """
+        Set the avro file of the agent.
+        """
+        self._avro_file = avro_file
+
     @property
     def uuid(self):
         """The Agent's UUID"""
@@ -214,8 +220,10 @@ class Agent(ABC):
     
     async def _process_survey(self, survey: dict):
         survey_response = await self.generate_user_survey_response(survey)
+        if self._avro_file is None:
+            return
         response_to_avro = [{
-            "id": str(self._uuid),
+            "id": self._uuid,
             "day": await self._simulator.get_simulator_day(),
             "t": await self._simulator.get_simulator_second_from_start_of_day(),
             "survey_id": survey["id"],
@@ -264,7 +272,7 @@ class Agent(ABC):
     
     async def _process_interview(self, payload: dict):
         auros = [{
-            "id": str(self._uuid),
+            "id": self._uuid,
             "day": await self._simulator.get_simulator_day(),
             "t": await self._simulator.get_simulator_second_from_start_of_day(),
             "type": 2,
@@ -275,7 +283,7 @@ class Agent(ABC):
         question = payload["content"]
         response = await self.generate_user_chat_response(question)
         auros.append({
-            "id": str(self._uuid),
+            "id": self._uuid,
             "day": await self._simulator.get_simulator_day(),
             "t": await self._simulator.get_simulator_second_from_start_of_day(),
             "type": 2,
@@ -283,15 +291,17 @@ class Agent(ABC):
             "content": response,
             "created_at": int(datetime.now().timestamp() * 1000),
         })
+        if self._avro_file is None:
+            return
         with open(self._avro_file["dialog"], "a+b") as f:
             fastavro.writer(f, DIALOG_SCHEMA, auros, codec="snappy")
 
     async def process_agent_chat_response(self, payload: dict) -> str:
-        logging.info(f"Agent {self._uuid} received agent chat response: {payload}")
+        logger.info(f"Agent {self._uuid} received agent chat response: {payload}")
 
     async def _process_agent_chat(self, payload: dict):
         auros = [{
-            "id": str(self._uuid),
+            "id": self._uuid,
             "day": payload["day"],
             "t": payload["t"],
             "type": 1,
@@ -300,6 +310,8 @@ class Agent(ABC):
             "created_at": int(datetime.now().timestamp() * 1000),
         }]
         asyncio.create_task(self.process_agent_chat_response(payload))
+        if self._avro_file is None:
+            return
         with open(self._avro_file["dialog"], "a+b") as f:
             fastavro.writer(f, DIALOG_SCHEMA, auros, codec="snappy")
 
@@ -307,19 +319,19 @@ class Agent(ABC):
     async def handle_agent_chat_message(self, payload: dict):
         """处理收到的消息，识别发送者"""
         # 从消息中解析发送者 ID 和消息内容
-        logging.info(f"Agent {self._uuid} received agent chat message: {payload}")
+        logger.info(f"Agent {self._uuid} received agent chat message: {payload}")
         asyncio.create_task(self._process_agent_chat(payload))
 
     async def handle_user_chat_message(self, payload: dict):
         """处理收到的消息，识别发送者"""
         # 从消息中解析发送者 ID 和消息内容
-        logging.info(f"Agent {self._uuid} received user chat message: {payload}")
+        logger.info(f"Agent {self._uuid} received user chat message: {payload}")
         asyncio.create_task(self._process_interview(payload))
 
     async def handle_user_survey_message(self, payload: dict):
         """处理收到的消息，识别发送者"""
         # 从消息中解析发送者 ID 和消息内容
-        logging.info(f"Agent {self._uuid} received user survey message: {payload}")
+        logger.info(f"Agent {self._uuid} received user survey message: {payload}")
         asyncio.create_task(self._process_survey(payload["data"]))
 
     async def handle_gather_message(self, payload: str):
@@ -327,7 +339,7 @@ class Agent(ABC):
 
     # MQTT send message
     async def _send_message(
-        self, to_agent_uuid: UUID, payload: dict, sub_topic: str
+        self, to_agent_uuid: str, payload: dict, sub_topic: str
     ):
         """通过 Messager 发送消息"""
         if self._messager is None:
@@ -336,7 +348,7 @@ class Agent(ABC):
         await self._messager.send_message(topic, payload)
 
     async def send_message_to_agent(
-        self, to_agent_uuid: UUID, content: str
+        self, to_agent_uuid: str, content: str
     ):
         """通过 Messager 发送消息"""
         if self._messager is None:
@@ -350,14 +362,16 @@ class Agent(ABC):
         }
         await self._send_message(to_agent_uuid, payload, "agent-chat")
         auros = [{
-            "id": str(self._uuid),
+            "id": self._uuid,
             "day": await self._simulator.get_simulator_day(),
             "t": await self._simulator.get_simulator_second_from_start_of_day(),
             "type": 1,
-            "speaker": str(self._uuid),
+            "speaker": self._uuid,
             "content": content,
             "created_at": int(datetime.now().timestamp() * 1000),
         }]
+        if self._avro_file is None:
+            return
         with open(self._avro_file["dialog"], "a+b") as f:
             fastavro.writer(f, DIALOG_SCHEMA, auros, codec="snappy")
 
@@ -414,7 +428,7 @@ class CitizenAgent(Agent):
             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")
+            logger.warning("Simulator is not set")
             return
         if not self._has_bound_to_simulator:
             FROM_MEMORY_KEYS = {
@@ -432,7 +446,7 @@ class CitizenAgent(Agent):
             # ATTENTION:模拟器分配的id从0开始
             if person_id >= 0:
                 await simulator.get_person(person_id)
-                logging.debug(f"Binding to Person `{person_id}` already in Simulator")
+                logger.debug(f"Binding to Person `{person_id}` already in Simulator")
             else:
                 dict_person = deepcopy(self._person_template)
                 for _key in FROM_MEMORY_KEYS:
@@ -447,7 +461,7 @@ class CitizenAgent(Agent):
                 )
                 person_id = resp["person_id"]
                 await memory.update("id", person_id, protect_llm_read_only_fields=False)
-                logging.debug(
+                logger.debug(
                     f"Binding to Person `{person_id}` just added to Simulator"
                 )
                 # 防止模拟器还没有到prepare阶段导致get_person出错
@@ -456,7 +470,7 @@ class CitizenAgent(Agent):
 
     async def _bind_to_economy(self):
         if self._economy_client is None:
-            logging.warning("Economy client is not set")
+            logger.warning("Economy client is not set")
             return
         if not self._has_bound_to_economy:
             if self._has_bound_to_simulator:
@@ -473,7 +487,7 @@ class CitizenAgent(Agent):
                 )
                 self._has_bound_to_economy = True
             else:
-                logging.debug(
+                logger.debug(
                     f"Binding to Economy before binding to Simulator, skip binding to Economy Simulator"
                 )
 
@@ -523,7 +537,7 @@ class InstitutionAgent(Agent):
 
     async def _bind_to_economy(self):
         if self._economy_client is None:
-            logging.debug("Economy client is not set")
+            logger.debug("Economy client is not set")
             return
         if not self._has_bound_to_economy:
             # TODO: More general id generation
@@ -599,7 +613,7 @@ class InstitutionAgent(Agent):
                     }
                 )
             except Exception as e:
-                logging.error(f"Failed to bind to Economy: {e}")
+                logger.error(f"Failed to bind to Economy: {e}")
             self._has_bound_to_economy = True
 
     async def handle_gather_message(self, payload: dict):
@@ -615,11 +629,11 @@ class InstitutionAgent(Agent):
                 "content": content,
             })
 
-    async def gather_messages(self, agent_ids: list[UUID], target: str) -> List[dict]:
+    async def gather_messages(self, agent_uuids: list[str], target: str) -> List[dict]:
         """从多个智能体收集消息
         
         Args:
-            agent_ids: 目标智能体ID列表
+            agent_uuids: 目标智能体UUID列表
             target: 要收集的信息类型
             
         Returns:
@@ -627,18 +641,17 @@ class InstitutionAgent(Agent):
         """
         # 为每个agent创建Future
         futures = {}
-        for agent_id in agent_ids:
-            response_key = str(agent_id)
-            futures[response_key] = asyncio.Future()
-            self._gather_responses[response_key] = futures[response_key]
+        for agent_uuid in agent_uuids:
+            futures[agent_uuid] = asyncio.Future()
+            self._gather_responses[agent_uuid] = futures[agent_uuid]
             
         # 发送gather请求
         payload = {
             "from": self._uuid,
             "target": target,
         }
-        for agent_id in agent_ids:
-            await self._send_message(agent_id, payload, "gather")
+        for agent_uuid in agent_uuids:
+            await self._send_message(agent_uuid, payload, "gather")
             
         try:
             # 等待所有响应

pycityagent/environment/simulator.py

@@ -20,6 +20,7 @@ from shapely.strtree import STRtree
 from .sim import CityClient, ControlSimEnv
 from .utils.const import *
 
+logger = logging.getLogger("pycityagent")
 
 class Simulator:
     """
@@ -72,7 +73,7 @@ class Simulator:
             else:
                 self._client = CityClient(config["simulator"]["server"], secure=False)
         else:
-            logging.warning(
+            logger.warning(
                 "No simulator config found, no simulator client will be used"
             )
         self.map = SimMap(
@@ -285,7 +286,7 @@ class Simulator:
             reset_position["aoi_position"] = {"aoi_id": aoi_id}
             if poi_id is not None:
                 reset_position["aoi_position"]["poi_id"] = poi_id
-            logging.debug(
+            logger.debug(
                 f"Setting person {person_id} pos to AoiPosition {reset_position}"
             )
             await self._client.person_service.ResetPersonPosition(
@@ -298,14 +299,14 @@ class Simulator:
             }
             if s is not None:
                 reset_position["lane_position"]["s"] = s
-            logging.debug(
+            logger.debug(
                 f"Setting person {person_id} pos to LanePosition {reset_position}"
             )
             await self._client.person_service.ResetPersonPosition(
                 {"person_id": person_id, "position": reset_position}
             )
         else:
-            logging.debug(
+            logger.debug(
                 f"Neither aoi or lane pos provided for person {person_id} position reset!!"
             )
 

pycityagent/memory/memory.py

@@ -13,6 +13,7 @@ from .profile import ProfileMemory
 from .self_define import DynamicMemory
 from .state import StateMemory
 
+logger = logging.getLogger("pycityagent")
 
 class Memory:
     """
@@ -83,7 +84,7 @@ class Memory:
                                 _type.extend(_value)
                                 _value = deepcopy(_type)
                             else:
-                                logging.warning(f"type `{_type}` is not supported!")
+                                logger.warning(f"type `{_type}` is not supported!")
                                 pass
                     except TypeError as e:
                         pass
@@ -99,7 +100,7 @@ class Memory:
                     or k in STATE_ATTRIBUTES
                     or k == TIME_STAMP_KEY
                 ):
-                    logging.warning(f"key `{k}` already declared in memory!")
+                    logger.warning(f"key `{k}` already declared in memory!")
                     continue
 
                 _dynamic_config[k] = deepcopy(_value)
@@ -112,19 +113,19 @@ class Memory:
         if profile is not None:
             for k, v in profile.items():
                 if k not in PROFILE_ATTRIBUTES:
-                    logging.warning(f"key `{k}` is not a correct `profile` field!")
+                    logger.warning(f"key `{k}` is not a correct `profile` field!")
                     continue
                 _profile_config[k] = v
         if motion is not None:
             for k, v in motion.items():
                 if k not in STATE_ATTRIBUTES:
-                    logging.warning(f"key `{k}` is not a correct `motion` field!")
+                    logger.warning(f"key `{k}` is not a correct `motion` field!")
                     continue
                 _state_config[k] = v
         if base is not None:
             for k, v in base.items():
                 if k not in STATE_ATTRIBUTES:
-                    logging.warning(f"key `{k}` is not a correct `base` field!")
+                    logger.warning(f"key `{k}` is not a correct `base` field!")
                     continue
                 _state_config[k] = v
         self._state = StateMemory(
@@ -182,7 +183,7 @@ class Memory:
         """更新记忆值并在必要时更新embedding"""
         if protect_llm_read_only_fields:
             if any(key in _attrs for _attrs in [STATE_ATTRIBUTES]):
-                logging.warning(f"Trying to write protected key `{key}`!")
+                logger.warning(f"Trying to write protected key `{key}`!")
                 return
         for _mem in [self._state, self._profile, self._dynamic]:
             try:
@@ -208,7 +209,7 @@ class Memory:
                     elif isinstance(original_value, deque):
                         original_value.extend(deque(value))
                     else:
-                        logging.debug(
+                        logger.debug(
                             f"Type of {type(original_value)} does not support mode `merge`, using `replace` instead!"
                         )
                         await _mem.update(key, value, store_snapshot)

pycityagent/memory/memory_base.py

@@ -10,6 +10,8 @@ from typing import Any, Callable, Dict, Optional, Sequence, Union
 
 from .const import *
 
+logger = logging.getLogger("pycityagent")
+
 
 class MemoryUnit:
     def __init__(
@@ -57,7 +59,7 @@ class MemoryUnit:
                 orig_v = self._content[k]
                 orig_type, new_type = type(orig_v), type(v)
                 if not orig_type == new_type:
-                    logging.debug(
+                    logger.debug(
                         f"Type warning: The type of the value for key '{k}' is changing from `{orig_type.__name__}` to `{new_type.__name__}`!"
                     )
         self._content.update(content)
@@ -82,7 +84,7 @@ class MemoryUnit:
         await self._lock.acquire()
         values = self._content[key]
         if not isinstance(values, Sequence):
-            logging.warning(
+            logger.warning(
                 f"the value stored in key `{key}` is not `sequence`, return value `{values}` instead!"
             )
             return values
@@ -93,7 +95,7 @@ class MemoryUnit:
             )
             top_k = len(values) if top_k is None else top_k
             if len(_sorted_values_with_idx) < top_k:
-                logging.debug(
+                logger.debug(
                     f"Length of values {len(_sorted_values_with_idx)} is less than top_k {top_k}, returning all values."
                 )
             self._lock.release()
@@ -149,7 +151,7 @@ class MemoryBase(ABC):
         if recent_n is None:
             return _list_units
         if len(_memories) < recent_n:
-            logging.debug(
+            logger.debug(
                 f"Length of memory {len(_memories)} is less than recent_n {recent_n}, returning all available memories."
             )
         return _list_units[-recent_n:]

pycityagent/message/messager.py

@@ -5,6 +5,7 @@ import logging
 import math
 from aiomqtt import Client
 
+logger = logging.getLogger("pycityagent")
 
 class Messager:
     def __init__(
@@ -21,15 +22,15 @@ class Messager:
         try:
             await self.client.__aenter__()
             self.connected = True
-            logging.info("Connected to MQTT Broker")
+            logger.info("Connected to MQTT Broker")
         except Exception as e:
             self.connected = False
-            logging.error(f"Failed to connect to MQTT Broker: {e}")
+            logger.error(f"Failed to connect to MQTT Broker: {e}")
 
     async def disconnect(self):
         await self.client.__aexit__(None, None, None)
         self.connected = False
-        logging.info("Disconnected from MQTT Broker")
+        logger.info("Disconnected from MQTT Broker")
 
     def is_connected(self):
         """检查是否成功连接到 Broker"""
@@ -37,13 +38,13 @@ class Messager:
 
     async def subscribe(self, topic, agent):
         if not self.is_connected():
-            logging.error(
+            logger.error(
                 f"Cannot subscribe to {topic} because not connected to the Broker."
             )
             return
         await self.client.subscribe(topic)
         self.subscribers[topic] = agent
-        logging.info(f"Subscribed to {topic} for Agent {agent._uuid}")
+        logger.info(f"Subscribed to {topic} for Agent {agent._uuid}")
 
     async def receive_messages(self):
         """监听并将消息存入队列"""
@@ -61,11 +62,11 @@ class Messager:
         """通过 Messager 发送消息"""
         message = json.dumps(payload, default=str)
         await self.client.publish(topic, message)
-        logging.info(f"Message sent to {topic}: {message}")
+        logger.info(f"Message sent to {topic}: {message}")
 
     async def start_listening(self):
         """启动消息监听任务"""
         if self.is_connected():
             asyncio.create_task(self.receive_messages())
         else:
-            logging.error("Cannot start listening because not connected to the Broker.")
+            logger.error("Cannot start listening because not connected to the Broker.")

pycityagent/simulation/agentgroup.py

@@ -2,27 +2,41 @@ import asyncio
 from datetime import datetime
 import json
 import logging
+from pathlib import Path
 import uuid
 import fastavro
 import ray
 from uuid import UUID
-from pycityagent.agent import Agent, CitizenAgent
+from pycityagent.agent import Agent, CitizenAgent, InstitutionAgent
 from pycityagent.economy.econ_client import EconomyClient
 from pycityagent.environment.simulator import Simulator
 from pycityagent.llm.llm import LLM
 from pycityagent.llm.llmconfig import LLMConfig
 from pycityagent.message import Messager
-from pycityagent.utils import STATUS_SCHEMA
+from pycityagent.utils import STATUS_SCHEMA, PROFILE_SCHEMA, DIALOG_SCHEMA, SURVEY_SCHEMA, INSTITUTION_STATUS_SCHEMA
 from typing import Any
 
+logger = logging.getLogger("pycityagent")
+
 @ray.remote
 class AgentGroup:
-    def __init__(self, agents: list[Agent], config: dict, exp_id: str|UUID, avro_file: dict):
+    def __init__(self, agents: list[Agent], config: dict, exp_id: str|UUID, enable_avro: bool, avro_path: Path, logging_level: int = logging.WARNING):
+        logger.setLevel(logging_level)
+        self._uuid = str(uuid.uuid4())
         self.agents = agents
         self.config = config
         self.exp_id = exp_id
-        self.avro_file = avro_file
-        self._uuid = uuid.uuid4()
+        self.enable_avro = enable_avro
+        self.avro_path = avro_path / f"{self._uuid}"
+        if enable_avro:
+            self.avro_path.mkdir(parents=True, exist_ok=True)
+            self.avro_file = {
+                "profile": self.avro_path / f"profile.avro",
+                "dialog": self.avro_path / f"dialog.avro",
+                "status": self.avro_path / f"status.avro",
+                "survey": self.avro_path / f"survey.avro",
+            }
+            
         self.messager = Messager(
             hostname=config["simulator_request"]["mqtt"]["server"],
             port=config["simulator_request"]["mqtt"]["port"],
@@ -33,16 +47,16 @@ class AgentGroup:
         self.id2agent = {}
         # Step:1 prepare LLM client
         llmConfig = LLMConfig(config["llm_request"])
-        logging.info("-----Creating LLM client in remote...")
+        logger.info(f"-----Creating LLM client in AgentGroup {self._uuid} ...")
         self.llm = LLM(llmConfig)
 
         # Step:2 prepare Simulator
-        logging.info("-----Creating Simulator in remote...")
+        logger.info(f"-----Creating Simulator in AgentGroup {self._uuid} ...")
         self.simulator = Simulator(config["simulator_request"])
 
         # Step:3 prepare Economy client
         if "economy" in config["simulator_request"]:
-            logging.info("-----Creating Economy client in remote...")
+            logger.info(f"-----Creating Economy client in AgentGroup {self._uuid} ...")
             self.economy_client = EconomyClient(
                 config["simulator_request"]["economy"]["server"]
             )
@@ -56,11 +70,16 @@ class AgentGroup:
             if self.economy_client is not None:
                 agent.set_economy_client(self.economy_client)
             agent.set_messager(self.messager)
+            if self.enable_avro:
+                agent.set_avro_file(self.avro_file)
 
     async def init_agents(self):
+        logger.debug(f"-----Initializing Agents in AgentGroup {self._uuid} ...")
+        logger.debug(f"-----Binding Agents to Simulator in AgentGroup {self._uuid} ...")
         for agent in self.agents:
             await agent.bind_to_simulator()
         self.id2agent = {agent._uuid: agent for agent in self.agents}
+        logger.debug(f"-----Binding Agents to Messager in AgentGroup {self._uuid} ...")
         await self.messager.connect()
         if self.messager.is_connected():
             await self.messager.start_listening()
@@ -74,27 +93,65 @@ class AgentGroup:
                 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
         self.message_dispatch_task = asyncio.create_task(self.message_dispatch())
-        
+        if self.enable_avro:
+            logger.debug(f"-----Creating Avro files in AgentGroup {self._uuid} ...")
+            # profile
+            if not issubclass(type(self.agents[0]), InstitutionAgent):
+                filename = self.avro_file["profile"]
+                with open(filename, "wb") as f:
+                    profiles = []
+                    for agent in self.agents:
+                        profile = await agent.memory._profile.export()
+                        profile = profile[0]
+                        profile['id'] = agent._uuid
+                        profiles.append(profile)
+                    fastavro.writer(f, PROFILE_SCHEMA, profiles)
+
+            # dialog
+            filename = self.avro_file["dialog"]
+            with open(filename, "wb") as f:
+                dialogs = []
+                fastavro.writer(f, DIALOG_SCHEMA, dialogs)
+
+            # status
+            filename = self.avro_file["status"]
+            with open(filename, "wb") as f:
+                statuses = []
+                if not issubclass(type(self.agents[0]), InstitutionAgent):
+                    fastavro.writer(f, STATUS_SCHEMA, statuses)
+                else:
+                    fastavro.writer(f, INSTITUTION_STATUS_SCHEMA, statuses)
+
+            # survey
+            filename = self.avro_file["survey"]
+            with open(filename, "wb") as f:
+                surveys = []
+                fastavro.writer(f, SURVEY_SCHEMA, surveys)
+        self.initialized = True
+        logger.debug(f"-----AgentGroup {self._uuid} initialized")
+
     async def gather(self, content: str):
+        logger.debug(f"-----Gathering {content} from all agents in group {self._uuid}")
         results = {}
         for agent in self.agents:
             results[agent._uuid] = await agent.memory.get(content)
         return results
 
     async def update(self, target_agent_uuid: str, target_key: str, content: Any):
+        logger.debug(f"-----Updating {target_key} for agent {target_agent_uuid} in group {self._uuid}")
         agent = self.id2agent[target_agent_uuid]
         await agent.memory.update(target_key, content)
 
     async def message_dispatch(self):
+        logger.debug(f"-----Starting message dispatch for group {self._uuid}")
         while True:
             if not self.messager.is_connected():
-                logging.warning("Messager is not connected. Skipping message processing.")
+                logger.warning("Messager is not connected. Skipping message processing.")
 
             # Step 1: 获取消息
             messages = await self.messager.fetch_messages()
-            logging.info(f"Group {self._uuid} received {len(messages)} messages")
+            logger.info(f"Group {self._uuid} received {len(messages)} messages")
 
             # Step 2: 分发消息到对应的 Agent
             for message in messages:
@@ -109,8 +166,8 @@ class AgentGroup:
                 # 提取 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)]
+                if agent_uuid in self.id2agent:
+                    agent = self.id2agent[agent_uuid]
                     # topic_type: agent-chat, user-chat, user-survey, gather
                     if topic_type == "agent-chat":
                         await agent.handle_agent_chat_message(payload)
@@ -123,46 +180,73 @@ class AgentGroup:
 
             await asyncio.sleep(0.5)
 
+    async def save_status(self):
+        if self.enable_avro:
+            logger.debug(f"-----Saving status for group {self._uuid}")
+            avros = []
+            if not issubclass(type(self.agents[0]), InstitutionAgent):
+                for agent in self.agents:
+                    position = await agent.memory.get("position")
+                    lng = position["longlat_position"]["longitude"]
+                    lat = position["longlat_position"]["latitude"]
+                    if "aoi_position" in position:
+                        parent_id = position["aoi_position"]["aoi_id"]
+                    elif "lane_position" in position:
+                        parent_id = position["lane_position"]["lane_id"]
+                    else:
+                        # BUG: 需要处理
+                        parent_id = -1
+                    needs = await agent.memory.get("needs")
+                    action = await agent.memory.get("current_step")
+                    action = action["intention"]
+                    avro = {
+                        "id": agent._uuid,
+                        "day": await self.simulator.get_simulator_day(),
+                        "t": await self.simulator.get_simulator_second_from_start_of_day(),
+                        "lng": lng,
+                        "lat": lat,
+                        "parent_id": parent_id,
+                        "action": action,
+                        "hungry": needs["hungry"],
+                        "tired": needs["tired"],
+                        "safe": needs["safe"],
+                        "social": needs["social"],
+                        "created_at": int(datetime.now().timestamp() * 1000),
+                    }
+                    avros.append(avro)
+                with open(self.avro_file["status"], "a+b") as f:
+                    fastavro.writer(f, STATUS_SCHEMA, avros, codec="snappy")
+            else:
+                for agent in self.agents:
+                    avro = {
+                        "id": agent._uuid,
+                        "day": await self.simulator.get_simulator_day(),
+                        "t": await self.simulator.get_simulator_second_from_start_of_day(),
+                        "type": await agent.memory.get("type"),
+                        "nominal_gdp": await agent.memory.get("nominal_gdp"),
+                        "real_gdp": await agent.memory.get("real_gdp"),
+                        "unemployment": await agent.memory.get("unemployment"),
+                        "wages": await agent.memory.get("wages"),
+                        "prices": await agent.memory.get("prices"),
+                        "inventory": await agent.memory.get("inventory"),
+                        "price": await agent.memory.get("price"),
+                        "interest_rate": await agent.memory.get("interest_rate"),
+                        "bracket_cutoffs": await agent.memory.get("bracket_cutoffs"),
+                        "bracket_rates": await agent.memory.get("bracket_rates"),
+                        "employees": await agent.memory.get("employees"),
+                        "customers": await agent.memory.get("customers"),
+                    }
+                    avros.append(avro)
+                with open(self.avro_file["status"], "a+b") as f:
+                    fastavro.writer(f, INSTITUTION_STATUS_SCHEMA, avros, codec="snappy")
+
     async def step(self):
         if not self.initialized:
             await self.init_agents()
 
         tasks = [agent.run() for agent in self.agents]
         await asyncio.gather(*tasks)
-        avros = []
-        for agent in self.agents:
-            if not issubclass(type(agent), CitizenAgent):
-                continue
-            position = await agent.memory.get("position")
-            lng = position["longlat_position"]["longitude"]
-            lat = position["longlat_position"]["latitude"]
-            if "aoi_position" in position:
-                parent_id = position["aoi_position"]["aoi_id"]
-            elif "lane_position" in position:
-                parent_id = position["lane_position"]["lane_id"]
-            else:
-                # BUG: 需要处理
-                parent_id = -1
-            needs = await agent.memory.get("needs")
-            action = await agent.memory.get("current_step")
-            action = action["intention"]
-            avro = {
-                "id": str(agent._uuid),  # uuid as string
-                "day": await self.simulator.get_simulator_day(),
-                "t": await self.simulator.get_simulator_second_from_start_of_day(),
-                "lng": lng,
-                "lat": lat,
-                "parent_id": parent_id,
-                "action": action,
-                "hungry": needs["hungry"],
-                "tired": needs["tired"],
-                "safe": needs["safe"],
-                "social": needs["social"],
-                "created_at": int(datetime.now().timestamp() * 1000),
-            }
-            avros.append(avro)
-        with open(self.avro_file["status"], "a+b") as f:
-            fastavro.writer(f, STATUS_SCHEMA, avros, codec="snappy")
+        await self.save_status()
 
     async def run(self, day: int = 1):
         """运行模拟器
@@ -185,5 +269,5 @@ class AgentGroup:
                 await self.step()
 
         except Exception as e:
-            logging.error(f"模拟器运行错误: {str(e)}")
+            logger.error(f"模拟器运行错误: {str(e)}")
             raise

pycityagent/simulation/simulation.py

@@ -4,21 +4,22 @@ import logging
 import os
 from pathlib import Path
 import uuid
-from datetime import datetime
+from datetime import datetime, timezone
 import random
 from typing import Dict, List, Optional, Callable, Union,Any
-import fastavro
 from mosstool.map._map_util.const import AOI_START_ID
 import pycityproto.city.economy.v2.economy_pb2 as economyv2
+from pycityagent.environment.simulator import Simulator
 from pycityagent.memory.memory import Memory
 from pycityagent.message.messager import Messager
 from pycityagent.survey import Survey
-from pycityagent.utils.avro_schema import PROFILE_SCHEMA, DIALOG_SCHEMA, STATUS_SCHEMA, SURVEY_SCHEMA
+import yaml
+from concurrent.futures import ThreadPoolExecutor
 
 from ..agent import Agent, InstitutionAgent
 from .agentgroup import AgentGroup
 
-logger = logging.getLogger(__name__)
+logger = logging.getLogger("pycityagent")
 
 
 class AgentSimulation:
@@ -29,19 +30,24 @@ class AgentSimulation:
         agent_class: Union[type[Agent], list[type[Agent]]],
         config: dict,
         agent_prefix: str = "agent_",
+        exp_name: str = "default_experiment",
+        logging_level: int = logging.WARNING
     ):
         """
         Args:
             agent_class: 智能体类
             config: 配置
             agent_prefix: 智能体名称前缀
+            exp_name: 实验名称
         """
-        self.exp_id = uuid.uuid4()
+        self.exp_id = str(uuid.uuid4())
         if isinstance(agent_class, list):
             self.agent_class = agent_class
         else:
             self.agent_class = [agent_class]
+        self.logging_level = logging_level
         self.config = config
+        self._simulator = Simulator(config["simulator_request"])
         self.agent_prefix = agent_prefix
         self._agents: Dict[uuid.UUID, Agent] = {}
         self._groups: Dict[str, AgentGroup] = {}
@@ -61,13 +67,10 @@ class AgentSimulation:
         asyncio.create_task(self._messager.connect())
 
         self._enable_avro = config["storage"]["avro"]["enabled"]
-        self._avro_path = Path(config["storage"]["avro"]["path"])
-        self._avro_file = {
-            "profile": self._avro_path / f"{self.exp_id}_profile.avro",
-            "dialog": self._avro_path / f"{self.exp_id}_dialog.avro",
-            "status": self._avro_path / f"{self.exp_id}_status.avro",
-            "survey": self._avro_path / f"{self.exp_id}_survey.avro",
-        }
+        if not self._enable_avro:
+            logger.warning("AVRO is not enabled, NO AVRO LOCAL STORAGE")
+        self._avro_path = Path(config["storage"]["avro"]["path"]) / f"{self.exp_id}"
+        self._avro_path.mkdir(parents=True, exist_ok=True)
 
         self._enable_pgsql = config["storage"]["pgsql"]["enabled"]
         self._pgsql_host = config["storage"]["pgsql"]["host"]
@@ -76,6 +79,24 @@ class AgentSimulation:
         self._pgsql_user = config["storage"]["pgsql"]["user"]
         self._pgsql_password = config["storage"]["pgsql"]["password"]
 
+        # 添加实验信息相关的属性
+        self._exp_info = {
+            "id": self.exp_id,
+            "name": exp_name,
+            "num_day": 0,  # 将在 run 方法中更新
+            "status": 0,
+            "cur_day": 0,
+            "cur_t": 0.0,
+            "config": json.dumps(config),
+            "error": "",
+            "created_at": datetime.now(timezone.utc).isoformat()
+        }
+        
+        # 创建异步任务保存实验信息
+        self._exp_info_file = self._avro_path / "experiment_info.yaml"
+        with open(self._exp_info_file, 'w') as f:
+            yaml.dump(self._exp_info, f)
+
     @property
     def agents(self):
         return self._agents
@@ -91,6 +112,11 @@ class AgentSimulation:
     @property
     def agent_uuid2group(self):
         return self._agent_uuid2group
+    
+    def create_remote_group(self, group_name: str, agents: list[Agent], config: dict, exp_id: str, enable_avro: bool, avro_path: Path, logging_level: int = logging.WARNING):
+        """创建远程组"""
+        group = AgentGroup.remote(agents, config, exp_id, enable_avro, avro_path, logging_level)
+        return group_name, group, agents
 
     async def init_agents(
         self,
@@ -112,7 +138,7 @@ class AgentSimulation:
             raise ValueError("agent_class和agent_count的长度不一致")
 
         if memory_config_func is None:
-            logging.warning(
+            logger.warning(
                 "memory_config_func is None, using default memory config function"
             )
             memory_config_func = []
@@ -125,17 +151,21 @@ class AgentSimulation:
             memory_config_func = [memory_config_func]
 
         if len(memory_config_func) != len(agent_count):
-            logging.warning(
+            logger.warning(
                 "memory_config_func和agent_count的长度不一致，使用默认的memory_config"
             )
             memory_config_func = []
             for agent_class in self.agent_class:
-                if agent_class == InstitutionAgent:
+                if issubclass(agent_class, InstitutionAgent):
                     memory_config_func.append(self.default_memory_config_institution)
                 else:
                     memory_config_func.append(self.default_memory_config_citizen)
 
+        # 使用线程池并行创建 AgentGroup
+        group_creation_params = []
         class_init_index = 0
+        
+        # 首先收集所有需要创建的组的参数
         for i in range(len(self.agent_class)):
             agent_class = self.agent_class[i]
             agent_count_i = agent_count[i]
@@ -153,7 +183,6 @@ class AgentSimulation:
                 agent = agent_class(
                     name=agent_name,
                     memory=memory,
-                    avro_file=self._avro_file,
                 )
 
                 self._agents[agent._uuid] = agent
@@ -161,66 +190,51 @@ class AgentSimulation:
 
             # 计算需要的组数,向上取整以处理不足一组的情况
             num_group = (agent_count_i + group_size - 1) // group_size
-
+            
             for k in range(num_group):
-                # 计算当前组的起始和结束索引
                 start_idx = class_init_index + k * group_size
                 end_idx = min(
-                    class_init_index + start_idx + group_size,
-                    class_init_index + agent_count_i,
+                    class_init_index + (k + 1) * group_size,  # 修正了索引计算
+                    class_init_index + agent_count_i
                 )
-
-                # 获取当前组的agents
+                
                 agents = list(self._agents.values())[start_idx:end_idx]
                 group_name = f"AgentType_{i}_Group_{k}"
-                group = AgentGroup.remote(agents, self.config, self.exp_id, self._avro_file)
-                self._groups[group_name] = group
-                for agent in agents:
-                    self._agent_uuid2group[agent._uuid] = group
-
-            class_init_index += agent_count_i  # 更新类初始索引
-
+                
+                # 收集创建参数
+                group_creation_params.append((
+                    group_name, 
+                    agents
+                ))
+            
+            class_init_index += agent_count_i
+
+        # 收集所有创建组的参数
+        creation_tasks = []
+        for group_name, agents in group_creation_params:
+            # 直接创建异步任务
+            group = AgentGroup.remote(agents, self.config, self.exp_id, 
+                                    self._enable_avro, self._avro_path, 
+                                    self.logging_level)
+            creation_tasks.append((group_name, group, agents))
+        
+        # 更新数据结构
+        for group_name, group, agents in creation_tasks:
+            self._groups[group_name] = group
+            for agent in agents:
+                self._agent_uuid2group[agent._uuid] = group
+
+        # 并行初始化所有组的agents
         init_tasks = []
         for group in self._groups.values():
             init_tasks.append(group.init_agents.remote())
         await asyncio.gather(*init_tasks)
+
+        # 设置用户主题
         for uuid, agent in self._agents.items():
             self._user_chat_topics[uuid] = f"exps/{self.exp_id}/agents/{uuid}/user-chat"
             self._user_survey_topics[uuid] = f"exps/{self.exp_id}/agents/{uuid}/user-survey"
 
-        # save profile
-        if self._enable_avro:
-            self._avro_path.mkdir(parents=True, exist_ok=True)
-            # profile
-            filename = self._avro_file["profile"]
-            with open(filename, "wb") as f:
-                profiles = []
-                for agent in self._agents.values():
-                    profile = await agent.memory._profile.export()
-                    profile = profile[0]
-                    profile['id'] = str(agent._uuid)
-                    profiles.append(profile)
-                fastavro.writer(f, PROFILE_SCHEMA, profiles)
-
-            # dialog
-            filename = self._avro_file["dialog"]
-            with open(filename, "wb") as f:
-                dialogs = []
-                fastavro.writer(f, DIALOG_SCHEMA, dialogs)
-
-            # status
-            filename = self._avro_file["status"]
-            with open(filename, "wb") as f:
-                statuses = []
-                fastavro.writer(f, STATUS_SCHEMA, statuses)
-
-            # survey
-            filename = self._avro_file["survey"]
-            with open(filename, "wb") as f:
-                surveys = []
-                fastavro.writer(f, SURVEY_SCHEMA, surveys)
-
-
     async def gather(self, content: str):
         """收集智能体的特定信息"""
         gather_tasks = []
@@ -228,10 +242,10 @@ class AgentSimulation:
             gather_tasks.append(group.gather.remote(content))
         return await asyncio.gather(*gather_tasks)
 
-    async def update(self, target_agent_id: str, target_key: str, content: Any):
+    async def update(self, target_agent_uuid: uuid.UUID, target_key: str, content: Any):
         """更新指定智能体的记忆"""
-        group = self._agent_uuid2group[target_agent_id]
-        await group.update.remote(target_agent_id, target_key, content)
+        group = self._agent_uuid2group[target_agent_uuid]
+        await group.update.remote(target_agent_uuid, target_key, content)
 
     def default_memory_config_institution(self):
         """默认的Memory配置函数"""
@@ -388,23 +402,88 @@ class AgentSimulation:
             logger.error(f"运行错误: {str(e)}")
             raise
 
-    async def run(
-        self,
-        day: int = 1,
-    ):
-        """运行模拟器
+    async def _save_exp_info(self) -> None:
+        """异步保存实验信息到YAML文件"""
+        try:
+            with open(self._exp_info_file, 'w') as f:
+                yaml.dump(self._exp_info, f)
+        except Exception as e:
+            logger.error(f"保存实验信息失败: {str(e)}")
+
+    async def _update_exp_status(self, status: int, error: str = "") -> None:
+        """更新实验状态并保存"""
+        self._exp_info["status"] = status
+        self._exp_info["error"] = error
+        await self._save_exp_info()
 
+    async def _monitor_exp_status(self, stop_event: asyncio.Event):
+        """监控实验状态并更新
+        
         Args:
-            day: 运行天数,默认为1天
+            stop_event: 用于通知监控任务停止的事件
         """
         try:
-            # 获取开始时间
-            tasks = []
-            for group in self._groups.values():
-                tasks.append(group.run.remote(day))
+            while not stop_event.is_set():  
+                # 更新实验状态
+                # 假设所有group的cur_day和cur_t是同步的，取第一个即可
+                self._exp_info["cur_day"] = await self._simulator.get_simulator_day()
+                self._exp_info["cur_t"] = await self._simulator.get_simulator_second_from_start_of_day()
+                await self._save_exp_info()
+                
+                await asyncio.sleep(1)  # 避免过于频繁的更新
+        except asyncio.CancelError:
+            # 正常取消，不需要特殊处理
+            pass
+        except Exception as e:
+            logger.error(f"监控实验状态时发生错误: {str(e)}")
+            raise
 
-            await asyncio.gather(*tasks)
+    async def run(
+        self,
+        day: int = 1,
+    ):
+        """运行模拟器"""
+        try:
+            self._exp_info["num_day"] += day
+            await self._update_exp_status(1)  # 更新状态为运行中
+            
+            # 创建停止事件
+            stop_event = asyncio.Event()
+            # 创建监控任务
+            monitor_task = asyncio.create_task(self._monitor_exp_status(stop_event))
+            
+            try:
+                tasks = []
+                for group in self._groups.values():
+                    tasks.append(group.run.remote())
+
+                # 等待所有group运行完成
+                await asyncio.gather(*tasks)
+                
+            finally:
+                # 设置停止事件
+                stop_event.set()
+                # 等待监控任务结束
+                await monitor_task
+            
+            # 运行成功后更新状态
+            await self._update_exp_status(2)
 
         except Exception as e:
-            logger.error(f"模拟器运行错误: {str(e)}")
-            raise
+            error_msg = f"模拟器运行错误: {str(e)}"
+            logger.error(error_msg)
+            await self._update_exp_status(3, error_msg)
+            raise e
+
+    async def __aenter__(self):
+        """异步上下文管理器入口"""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """异步上下文管理器出口"""
+        if exc_type is not None:
+            # 如果发生异常，更新状态为错误
+            await self._update_exp_status(3, str(exc_val))
+        elif self._exp_info["status"] != 3:
+            # 如果没有发生异常且状态不是错误，则更新为完成
+            await self._update_exp_status(2)

pycityagent/utils/__init__.py

@@ -1,7 +1,7 @@
-from .avro_schema import PROFILE_SCHEMA, DIALOG_SCHEMA, STATUS_SCHEMA, SURVEY_SCHEMA
+from .avro_schema import PROFILE_SCHEMA, DIALOG_SCHEMA, STATUS_SCHEMA, SURVEY_SCHEMA, INSTITUTION_STATUS_SCHEMA
 from .survey_util import process_survey_for_llm
 
 __all__ = [
-    "PROFILE_SCHEMA", "DIALOG_SCHEMA", "STATUS_SCHEMA", "SURVEY_SCHEMA",
+    "PROFILE_SCHEMA", "DIALOG_SCHEMA", "STATUS_SCHEMA", "SURVEY_SCHEMA", "INSTITUTION_STATUS_SCHEMA",
     "process_survey_for_llm"
 ]

pycityagent/utils/avro_schema.py

@@ -66,6 +66,31 @@ STATUS_SCHEMA = {
     ],
 }
 
+INSTITUTION_STATUS_SCHEMA = {
+    "doc": "Institution状态",
+    "name": "InstitutionStatus",
+    "namespace": "com.socialcity",
+    "type": "record",
+    "fields": [
+        {"name": "id", "type": "string"},  # uuid as string
+        {"name": "day", "type": "int"},
+        {"name": "t", "type": "float"},
+        {"name": "type", "type": "int"},
+        {"name": "nominal_gdp", "type": {"type": "array", "items": ["float", "int", "string", "null"]}},
+        {"name": "real_gdp", "type": {"type": "array", "items": ["float", "int", "string", "null"]}},
+        {"name": "unemployment", "type": {"type": "array", "items": ["float", "int", "string", "null"]}},
+        {"name": "wages", "type": {"type": "array", "items": ["float", "int", "string", "null"]}},
+        {"name": "prices", "type": {"type": "array", "items": ["float", "int", "string", "null"]}},
+        {"name": "inventory", "type": ["int", "null"]},
+        {"name": "price", "type": ["float", "null"]},
+        {"name": "interest_rate", "type": ["float", "null"]},
+        {"name": "bracket_cutoffs", "type": {"type": "array", "items": ["float", "int", "string", "null"]}},
+        {"name": "bracket_rates", "type": {"type": "array", "items": ["float", "int", "string", "null"]}},
+        {"name": "employees", "type": {"type": "array", "items": ["float", "int", "string", "null"]}},
+        {"name": "customers", "type": {"type": "array", "items": ["float", "int", "string", "null"]}},
+    ],
+}
+
 SURVEY_SCHEMA = {
     "doc": "Agent问卷",
     "name": "AgentSurvey",
@@ -82,4 +107,4 @@ SURVEY_SCHEMA = {
             "type": {"type": "long", "logicalType": "timestamp-millis"},
         },
     ],
-}
+}

pycityagent/workflow/tool.py

@@ -1,6 +1,3 @@
-import asyncio
-import logging
-from copy import deepcopy
 from typing import Any, Callable, Dict, List, Optional, Union
 
 from ..agent import Agent

{pycityagent-2.0.0a14.dist-info → pycityagent-2.0.0a15.dist-info}/METADATA

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

{pycityagent-2.0.0a14.dist-info → pycityagent-2.0.0a15.dist-info}/RECORD

@@ -1,5 +1,5 @@
-pycityagent/__init__.py,sha256=n56bWkAUEcvjDsb7LcJpaGjlrriSKPnR0yBhwRfEYBA,212
-pycityagent/agent.py,sha256=0ZqHXImR05ETA0vt9t5GDS4AgYzza3-Zwuua2OckwTw,22788
+pycityagent/__init__.py,sha256=EDxt3Su3lH1IMh9suNw7GeGL7UrXeWiZTw5KWNznDzc,637
+pycityagent/agent.py,sha256=fcuKX6FtMzjNP8lVep9pG-9KHzHQwJ8IymJbmLKMfu0,23109
 pycityagent/economy/__init__.py,sha256=aonY4WHnx-6EGJ4WKrx4S-2jAkYNLtqUA04jp6q8B7w,75
 pycityagent/economy/econ_client.py,sha256=wcuNtcpkSijJwNkt2mXw3SshYy4SBy6qbvJ0VQ7Aovo,10854
 pycityagent/environment/__init__.py,sha256=awHxlOud-btWbk0FCS4RmGJ13W84oVCkbGfcrhKqihA,240
@@ -21,7 +21,7 @@ pycityagent/environment/sim/person_service.py,sha256=nIvOsoBoqOTDYtsiThg07-4ZBgk
 pycityagent/environment/sim/road_service.py,sha256=phKTwTyhc_6Ht2mddEXpdENfl-lRXIVY0CHAlw1yHjI,1264
 pycityagent/environment/sim/sim_env.py,sha256=HI1LcS_FotDKQ6vBnx0e49prXSABOfA20aU9KM-ZkCY,4625
 pycityagent/environment/sim/social_service.py,sha256=6Iqvq6dz8H2jhLLdtaITc6Js9QnQw-Ylsd5AZgUj3-E,1993
-pycityagent/environment/simulator.py,sha256=fQv6D_1OnhUrKTsnnah3wnm9ec8LE1phxRhK1K93Zyg,12466
+pycityagent/environment/simulator.py,sha256=K7IyhiGC9BxanW28bpML4M0YREdMp1h7yMoWBlbf3RY,12504
 pycityagent/environment/utils/__init__.py,sha256=1m4Q1EfGvNpUsa1bgQzzCyWhfkpElnskNImjjFD3Znc,237
 pycityagent/environment/utils/base64.py,sha256=hoREzQo3FXMN79pqQLO2jgsDEvudciomyKii7MWljAM,374
 pycityagent/environment/utils/const.py,sha256=3RMNy7_bE7-23K90j9DFW_tWEzu8s7hSTgKbV-3BFl4,5327
@@ -37,22 +37,22 @@ pycityagent/llm/llmconfig.py,sha256=4Ylf4OFSBEFy8jrOneeX0HvPhWEaF5jGvy1HkXK08Ro,
 pycityagent/llm/utils.py,sha256=hoNPhvomb1u6lhFX0GctFipw74hVKb7bvUBDqwBzBYw,160
 pycityagent/memory/__init__.py,sha256=Hs2NhYpIG-lvpwPWwj4DydB1sxtjz7cuA4iDAzCXnjI,243
 pycityagent/memory/const.py,sha256=6zpJPJXWoH9-yf4RARYYff586agCoud9BRn7sPERB1g,932
-pycityagent/memory/memory.py,sha256=sDbaqr1Koqf_9joMtG9PmmVxJZ6Rq7nAZO6EO0OdVgo,18148
-pycityagent/memory/memory_base.py,sha256=bd2q0qNu5hCRd2u4cPxE3bBA2OaoAD1oR4-vbRdbd_s,5594
+pycityagent/memory/memory.py,sha256=FjKVL_MgNBnSc0sox2tuxLqXg9_MQQr9vYdRDHMdDL4,18183
+pycityagent/memory/memory_base.py,sha256=euKZRCs4dbcKxjlZzpLCTnH066DAtRjj5g1JFKD40qQ,5633
 pycityagent/memory/profile.py,sha256=s4LnxSPGSjIGZXHXkkd8mMa6uYYZrytgyQdWjcaqGf4,5182
 pycityagent/memory/self_define.py,sha256=poPiexNhOLq_iTgK8s4mK_xoL_DAAcB8kMvInj7iE5E,5179
 pycityagent/memory/state.py,sha256=5W0c1yJ-aaPpE74B2LEcw3Ygpm77tyooHv8NylyrozE,5113
 pycityagent/memory/utils.py,sha256=wLNlNlZ-AY9VB8kbUIy0UQSYh26FOQABbhmKQkit5o8,850
 pycityagent/message/__init__.py,sha256=TCjazxqb5DVwbTu1fF0sNvaH_EPXVuj2XQ0p6W-QCLU,55
-pycityagent/message/messager.py,sha256=Iv4pK83JvHAQSZyGNACryPBey2wRoiok3Hb1eIwHbww,2506
+pycityagent/message/messager.py,sha256=W_OVlNGcreHSBf6v-DrEnfNCXExB78ySr0w26MSncfU,2541
 pycityagent/simulation/__init__.py,sha256=jYaqaNpzM5M_e_ykISS_M-mIyYdzJXJWhgpfBpA6l5k,111
-pycityagent/simulation/agentgroup.py,sha256=ZJIeQbFmFwK3iUiwUpa4TG-k1Eb4vOTgy5ybv-CE1Rc,7797
-pycityagent/simulation/simulation.py,sha256=rDQRgKmJkjfeQtvXyW9LeqBVVX0iFh6snBEsdg1bCag,15574
+pycityagent/simulation/agentgroup.py,sha256=JwfssUtVrOgSnJCan4jcIcSHLjWBCwYxqOPT-AXA2sE,12514
+pycityagent/simulation/simulation.py,sha256=G68P1EJ3JceA3zID2O6AGd_KdhhYy5XVZVUgkfJHypc,18897
 pycityagent/survey/__init__.py,sha256=rxwou8U9KeFSP7rMzXtmtp2fVFZxK4Trzi-psx9LPIs,153
 pycityagent/survey/manager.py,sha256=N4-Q8vve4L-PLaFikAgVB4Z8BNyFDEd6WjEk3AyMTgs,1764
 pycityagent/survey/models.py,sha256=Z2gHEazQRj0TkTz5qbh4Uy_JrU_FZGWpOLwjN0RoUrY,3547
-pycityagent/utils/__init__.py,sha256=_0AV01UAHp4pTj2mlJ4m8LTH0toWL9j3DouNC6sDuUQ,249
-pycityagent/utils/avro_schema.py,sha256=MsRG0CsYAn2UjSlSXgCF8-3076VywpALEmz1mW-UJB0,2789
+pycityagent/utils/__init__.py,sha256=xXEMhVfFeOJUXjczaHv9DJqYNp57rc6FibtS7CfrVbA,305
+pycityagent/utils/avro_schema.py,sha256=DHM3bOo8m0dJf8oSwyOWzVeXrH6OERmzA_a5vS4So4M,4255
 pycityagent/utils/decorators.py,sha256=Gk3r41hfk6awui40tbwpq3C7wC7jHaRmLRlcJFlLQCE,3160
 pycityagent/utils/parsers/__init__.py,sha256=AN2xgiPxszWK4rpX7zrqRsqNwfGF3WnCA5-PFTvbaKk,281
 pycityagent/utils/parsers/code_block_parser.py,sha256=Cs2Z_hm9VfNCpPPll1TwteaJF-HAQPs-3RApsOekFm4,1173
@@ -62,8 +62,8 @@ pycityagent/utils/survey_util.py,sha256=Be9nptmu2JtesFNemPgORh_2GsN7rcDYGQS9Zfvc
 pycityagent/workflow/__init__.py,sha256=EyCcjB6LyBim-5iAOPe4m2qfvghEPqu1ZdGfy4KPeZ8,551
 pycityagent/workflow/block.py,sha256=6EmiRMLdOZC1wMlmLMIjfrp9TuiI7Gw4s3nnXVMbrnw,6031
 pycityagent/workflow/prompt.py,sha256=tY69nDO8fgYfF_dOA-iceR8pAhkYmCqoox8uRPqEuGY,2956
-pycityagent/workflow/tool.py,sha256=wD9WZ5rma6HCKugtHTwbShNE0f-Rjlwvn_1be3fCAsk,6682
+pycityagent/workflow/tool.py,sha256=zMvz3BV4QBs5TqyQ3ziJxj4pCfL2uqUI3A1FbT1gd3Q,6626
 pycityagent/workflow/trigger.py,sha256=t5X_i0WtL32bipZSsq_E3UUyYYudYLxQUpvxbgClp2s,5683
-pycityagent-2.0.0a14.dist-info/METADATA,sha256=O6cGdAHKuG6W0Ya_Du_wEP8_xfM4xmOetYWb6rPj-WM,7705
-pycityagent-2.0.0a14.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-pycityagent-2.0.0a14.dist-info/RECORD,,
+pycityagent-2.0.0a15.dist-info/METADATA,sha256=8ONKHaTIPOGja6FKJDE9tZ-pLZL2aeXQufB-LWkElR8,7705
+pycityagent-2.0.0a15.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+pycityagent-2.0.0a15.dist-info/RECORD,,