pycityagent 2.0.0a52__cp39-cp39-macosx_11_0_arm64.whl → 2.0.0a53__cp39-cp39-macosx_11_0_arm64.whl

pycityagent/cityagent/blocks/plan_block.py

@@ -18,6 +18,8 @@ Available options: {options}
 Current location: {current_location}
 Current time: {current_time}
 Current Environment: {environment}
+Your emotion: {emotion_types}
+Your thought: {thought}
 
 Please evaluate and select the most appropriate option based on these three dimensions:
 1. Attitude: Personal preference and evaluation of the option
@@ -26,7 +28,7 @@ Please evaluate and select the most appropriate option based on these three dime
 
 Please return the evaluation results in JSON format (Do not return any other text):
 {{
-    "selected_option": "Select the most suitable option from available choices",
+    "selected_option": "Select the most suitable option from available options",
     "evaluation": {{
         "attitude": "Attitude score for the option (0-1)",
         "subjective_norm": "Subjective norm score (0-1)", 
@@ -42,6 +44,8 @@ Selected plan: {selected_option}
 Current location: {current_location} 
 Current time: {current_time}
 Current Environment: {environment}
+Your emotion: {emotion_types}
+Your thought: {thought}
 
 Please generate specific execution steps and return in JSON format:
 {{
@@ -148,26 +152,20 @@ Example outputs (Do not return any other text):
 """
 
 class PlanBlock(Block):
-    configurable_fields: List[str] = ["guidance_options", "max_plan_steps"]
+    configurable_fields: List[str] = ["max_plan_steps"]
     default_values = {
-        "guidance_options": {
-            "hungry": ['Eat at home', 'Eat outside'],
-            "tired": ['Sleep', 'Take a nap'],
-            "safe": ['Work'],
-            "social": ['Online social', 'Shopping'],
-            "whatever": ['Learning', 'Entertainment', 'Hang out', 'Exercise']
-        },
         "max_plan_steps": 6
     }
+    fields_description = {
+        "max_plan_steps": "The maximum number of steps in a plan"
+    }
 
     def __init__(self, llm: LLM, memory: Memory, simulator: Simulator):
-        super().__init__("PlanBlock", llm, memory, simulator)
+        super().__init__("PlanBlock", llm=llm, memory=memory, simulator=simulator)
         self.guidance_prompt = FormatPrompt(template=GUIDANCE_SELECTION_PROMPT)
         self.detail_prompt = FormatPrompt(template=DETAILED_PLAN_PROMPT)
         self.trigger_time = 0
         self.token_consumption = 0
-
-        # configurable fields
         self.guidance_options = {
             "hungry": ['Eat at home', 'Eat outside'],
             "tired": ['Sleep', 'Take a nap'],
@@ -175,30 +173,31 @@ class PlanBlock(Block):
             "social": ['Online social', 'Shopping'],
             "whatever": ['Learning', 'Entertainment', 'Hang out', 'Exercise']
         }
+
+        # configurable fields
         self.max_plan_steps = 6
 
     async def select_guidance(self, current_need: str) -> Dict:
-        """选择指导方案"""
-        options = self.guidance_options.get(current_need, [])
-        if not options:
-            return None # type: ignore–
-
-        position_now = await self.memory.get("position")
-        home_location = await self.memory.get("home")
-        work_location = await self.memory.get("work")
+        """Select guidance plan"""
+        position_now = await self.memory.status.get("position")
+        home_location = await self.memory.status.get("home")
+        work_location = await self.memory.status.get("work")
         current_location = "Out"
         if 'aoi_position' in position_now and position_now['aoi_position'] == home_location['aoi_position']:
             current_location = "At home"
         elif 'aoi_position' in position_now and position_now['aoi_position'] == work_location['aoi_position']:
             current_location = "At workplace"
         current_time = await self.simulator.get_time(format_time=True)
-        environment = await self.memory.get("environment")
+        environment = await self.memory.status.get("environment")
+        options = self.guidance_options.get(current_need, [])
         self.guidance_prompt.format(
             current_need=current_need,
             options=options,
             current_location=current_location,
             current_time=current_time,
-            environment=environment
+            environment=environment,
+            emotion_types=await self.memory.status.get("emotion_types"),
+            thought=await self.memory.status.get("thought")
         )
 
         response = await self.llm.atext_request(
@@ -207,32 +206,30 @@ class PlanBlock(Block):
 
         try:
             result = json.loads(self.clean_json_response(response)) # type: ignore
-            if result['selected_option'] not in options:
-                result['selected_option'] = random.choice(options)
-            logger.info(f"\n=== Plan Selection ===")
-            logger.info(f"Selected Plan: {result['selected_option']}")
             return result
         except Exception as e:
             logger.warning(f"Error parsing guidance selection response: {str(e)}")
             return None # type: ignore
 
     async def generate_detailed_plan(self, current_need: str, selected_option: str) -> Dict:
-        """生成具体执行计划"""
-        position_now = await self.memory.get("position")
-        home_location = await self.memory.get("home")
-        work_location = await self.memory.get("work")
+        """Generate detailed execution plan"""
+        position_now = await self.memory.status.get("position")
+        home_location = await self.memory.status.get("home")
+        work_location = await self.memory.status.get("work")
         current_location = "Out"
         if 'aoi_position' in position_now and position_now['aoi_position'] == home_location['aoi_position']:
             current_location = "At home"
         elif 'aoi_position' in position_now and position_now['aoi_position'] == work_location['aoi_position']:
             current_location = "At workplace"
         current_time = await self.simulator.get_time(format_time=True)
-        environment = await self.memory.get("environment")
+        environment = await self.memory.status.get("environment")
         self.detail_prompt.format(
             selected_option=selected_option,
             current_location=current_location,
             current_time=current_time,
             environment=environment,
+            emotion_types=await self.memory.status.get("emotion_types"),
+            thought=await self.memory.status.get("thought"),
             max_plan_steps=self.max_plan_steps
         )
 
@@ -250,36 +247,25 @@ class PlanBlock(Block):
     async def forward(self):
         self.trigger_time += 1
         consumption_start = self.llm.prompt_tokens_used + self.llm.completion_tokens_used
-
-        current_need = await self.memory.get("current_need")
-        if current_need == "none":
-            await self.memory.update("current_plan", [])
-            await self.memory.update("current_step", {"intention": "", "type": ""})
-            return
-
-        # 第一步：选择指导方案
+        
+        # Step 1: Select guidance plan
+        current_need = await self.memory.status.get("current_need")
         guidance_result = await self.select_guidance(current_need)
         if not guidance_result:
             return
 
-        # 第二步：生成具体计划
+        # Step 2: Generate detailed plan
         detailed_plan = await self.generate_detailed_plan(
             current_need, 
             guidance_result["selected_option"]
         )
         
         if not detailed_plan or "plan" not in detailed_plan:
-            await self.memory.update("current_plan", [])
-            await self.memory.update("current_step", {"intention": "", "type": ""})
+            await self.memory.status.update("current_plan", [])
+            await self.memory.status.update("current_step", {"intention": "", "type": ""})
             return
-        logger.info("\n=== Plan Generation ===")
-        logger.info(f"Target: {detailed_plan['plan']['target']}")
-        logger.info("\nExecution Steps:")
-        for i, step in enumerate(detailed_plan['plan']['steps'], 1):
-            logger.info(f"{i}. {step['intention']} ({step['type']})")
-        logger.info("===============\n")
         
-        # 更新计划和当前步骤
+        # Step 3: Update plan and current step
         steps = detailed_plan["plan"]["steps"]
         for step in steps:
             step["evaluation"] = {"status": "pending", "details": ""}
@@ -288,22 +274,24 @@ class PlanBlock(Block):
             "target": detailed_plan["plan"]["target"],
             "steps": steps,
             "completed": False,
-            "guidance": guidance_result  # 保存方案选择的评估结果
+            "failed": False,
+            "stream_nodes": [],
+            "guidance": guidance_result  # Save the evaluation result of the plan selection
         }
         formated_steps = "\n".join([f"{i}. {step['intention']}" for i, step in enumerate(plan['steps'], 1)])
         formated_plan = f"""
-        Overall Target: {plan['target']}
-        Execution Steps: \n{formated_steps}
+Overall Target: {plan['target']}
+Execution Steps: \n{formated_steps}
         """
         plan['start_time'] = await self.simulator.get_time(format_time=True)
-        await self.memory.update("current_plan", plan)
-        await self.memory.update("current_step", steps[0] if steps else {"intention": "", "type": ""})
-        await self.memory.update("execution_context", {'plan': formated_plan})
+        await self.memory.status.update("current_plan", plan)
+        await self.memory.status.update("current_step", steps[0] if steps else {"intention": "", "type": ""})
+        await self.memory.status.update("execution_context", {'plan': formated_plan})
 
         consumption_end = self.llm.prompt_tokens_used + self.llm.completion_tokens_used
         self.token_consumption += consumption_end - consumption_start
 
     def clean_json_response(self, response: str) -> str:
-        """清理LLM响应中的特殊字符"""
+        """Clean special characters in LLM response"""
         response = response.replace('```json', '').replace('```', '')
         return response.strip() 

pycityagent/cityagent/blocks/social_block.py

@@ -23,8 +23,8 @@ class MessagePromptManager:
     async def get_prompt(self, memory, step: Dict[str, Any], target: str) -> str:
         """在这里改给模板输入的数据"""
         # 获取数据
-        relationships = await memory.get("relationships") or {}
-        chat_histories = await memory.get("chat_histories") or {}
+        relationships = await memory.status.get("relationships") or {}
+        chat_histories = await memory.status.get("chat_histories") or {}
 
         # 构建讨论话题约束
         discussion_constraint = ""
@@ -34,12 +34,14 @@ class MessagePromptManager:
         
         # 格式化提示
         self.format_prompt.format(
-            gender=await memory.get("gender") or "",
-            education=await memory.get("education") or "",
-            personality=await memory.get("personality") or "",
-            occupation=await memory.get("occupation") or "",
+            gender=await memory.status.get("gender") or "",
+            education=await memory.status.get("education") or "",
+            personality=await memory.status.get("personality") or "",
+            occupation=await memory.status.get("occupation") or "",
             relationship_score=relationships.get(target, 50),
             intention=step.get("intention", ""),
+            emotion_types=await memory.status.get("emotion_types"),
+            thought=await memory.status.get("thought"),
             chat_history=chat_histories.get(target, "") if isinstance(chat_histories, dict) else "",
             discussion_constraint=discussion_constraint
         )
@@ -52,47 +54,57 @@ class SocialNoneBlock(Block):
     NoneBlock
     """
     def __init__(self, llm: LLM, memory: Memory):
-        super().__init__("NoneBlock", llm, memory)
+        super().__init__("NoneBlock", llm=llm, memory=memory)
         self.description = "Handle all other cases"
         self.guidance_prompt = FormatPrompt(template=TIME_ESTIMATE_PROMPT)
 
     async def forward(self, step, context):
-        self.guidance_prompt.format(intention=step['intention'])
+        self.guidance_prompt.format(plan=context['plan'],
+                                    intention=step['intention'],
+                                    emotion_types=await self.memory.status.get("emotion_types"))
         result = await self.llm.atext_request(self.guidance_prompt.to_dialog())
         result = clean_json_response(result)
         try:
             result = json.loads(result)
+            node_id = await self.memory.stream.add_social(description=f"I {step['intention']}")
             return {
                 'success': True,
-                'evaluation': f'完成执行{step["intention"]}',
-                'consumed_time': result['time']
+                'evaluation': f'Finished {step["intention"]}',
+                'consumed_time': result['time'],
+                'node_id': node_id
             }
         except Exception as e:
             logger.warning(f"解析时间评估响应时发生错误: {str(e)}, 原始结果: {result}")
+            node_id = await self.memory.stream.add_social(description=f"I failed to execute {step['intention']}")
             return {
                 'success': False,
-                'evaluation': f'完成执行{step["intention"]}',
-                'consumed_time': random.randint(1, 100)
+                'evaluation': f'Failed to execute {step["intention"]}',
+                'consumed_time': 5,
+                'node_id': node_id
             }
 
 class FindPersonBlock(Block):
     """寻找社交对象"""
     def __init__(self, llm: LLM, memory: Memory, simulator: Simulator):
-        super().__init__("FindPersonBlock", llm, memory, simulator)
+        super().__init__("FindPersonBlock", llm=llm, memory=memory, simulator=simulator)
         self.description = "Find a suitable person to socialize with"
 
         self.prompt = """
         Based on the following information, help me select the most suitable friend to interact with:
 
-        1. My Profile:
+        1. Your Profile:
            - Gender: {gender}
            - Education: {education}
            - Personality: {personality}
            - Occupation: {occupation}
 
-        2. My Current Intention: {intention}
+        2. Your Current Intention: {intention}
 
-        3. My Friends List (shown as index-to-relationship pairs):
+        3. Your Current Emotion: {emotion_types}
+
+        4. Your Current Thought: {thought}
+
+        5. Your Friends List (shown as index-to-relationship pairs):
            {friend_info}
            Note: For each friend, the relationship strength (0-100) indicates how close we are
 
@@ -112,26 +124,20 @@ class FindPersonBlock(Block):
 
     async def forward(self, step: Dict[str, Any], context: Optional[Dict] = None) -> Dict[str, Any]:
         try:
-            # 获取用户个人资料
-            profile = {
-                "gender": await self.memory.get("gender"),
-                "education": await self.memory.get("education"),
-                "personality": await self.memory.get("personality"),
-                "occupation": await self.memory.get("occupation")
-            }
-            
-            # 获取朋友列表和关系强度
-            friends = await self.memory.get("friends") or []
-            relationships = await self.memory.get("relationships") or {}
+            # Get friends list and relationship strength
+            friends = await self.memory.status.get("friends") or []
+            relationships = await self.memory.status.get("relationships") or {}
             
             if not friends:
+                node_id = await self.memory.stream.add_social(description=f"I can't find any friends to socialize with.")
                 return {
                     'success': False,
                     'evaluation': 'No friends found in social network',
-                    'consumed_time': 5
+                    'consumed_time': 5,
+                    'node_id': node_id
                 }
             
-            # 创建包含所有信息的朋友列表
+            # Create a list of friends with all information
             friend_info = []
             index_to_uuid = {}
             
@@ -143,57 +149,63 @@ class FindPersonBlock(Block):
                 })
                 index_to_uuid[i] = friend_id
             
-            # 格式化朋友信息为更易读的格式
+            # Format friend information for easier reading
             formatted_friend_info = {
                 i: {'relationship_strength': info['relationship_strength']}
                 for i, info in enumerate(friend_info)
             }
             
-            # 格式化提示
+            # Format the prompt
             formatted_prompt = FormatPrompt(self.prompt)
             formatted_prompt.format(
-                gender=str(await self.memory.get("gender")),
-                education=str(await self.memory.get("education")),
-                personality=str(await self.memory.get("personality")),
-                occupation=str(await self.memory.get("occupation")),
+                gender=str(await self.memory.status.get("gender")),
+                education=str(await self.memory.status.get("education")),
+                personality=str(await self.memory.status.get("personality")),
+                occupation=str(await self.memory.status.get("occupation")),
                 intention=str(step.get("intention", "socialize")),
+                emotion_types=str(await self.memory.status.get("emotion_types")),
+                thought=str(await self.memory.status.get("thought")),
                 friend_info=str(formatted_friend_info)
             )
             
-            # 获取LLM响应
+            # Get LLM response
             response = await self.llm.atext_request(formatted_prompt.to_dialog(), timeout=300)
             
             try:
-                # 解析响应
+                # Parse the response
                 mode, friend_index = eval(response)
                 
-                # 验证响应格式
+                # Validate the response format
                 if not isinstance(mode, str) or mode not in ['online', 'offline']:
                     raise ValueError("Invalid mode")
                 if not isinstance(friend_index, int) or friend_index not in index_to_uuid:
                     raise ValueError("Invalid friend index")
                 
-                # 将索引转换为UUID
+                # Convert index to UUID
                 target = index_to_uuid[friend_index]
                 context['target']=target
             except Exception as e:
-                # 如果解析失败，选择关系最强的朋友作为默认选项
+                # If parsing fails, select the friend with the strongest relationship as the default option
                 target = max(relationships.items(), key=lambda x: x[1])[0] if relationships else friends[0]
                 mode = 'online'
-                
+            
+            node_id = await self.memory.stream.add_social(description=f"I selected the friend {target} for {mode} interaction")
             return {
                 'success': True,
                 'evaluation': f'Selected friend {target} for {mode} interaction',
                 'consumed_time': 15,
                 'mode': mode,
-                'target': target
+                'target': target,
+                'node_id': node_id
             }
         
         except Exception as e:
+            node_id = await self.memory.stream.add_social(description=f"I can't find any friends to socialize with.")
             return {
                 'success': False,
                 'evaluation': f'Error in finding person: {str(e)}',
-                'consumed_time': 5
+                'consumed_time': 5,
+                'node_id': node_id
             }
 
 class MessageBlock(Block):
@@ -209,7 +221,7 @@ class MessageBlock(Block):
     }
     
     def __init__(self, agent, llm: LLM, memory: Memory, simulator: Simulator):
-        super().__init__("MessageBlock", llm, memory, simulator)
+        super().__init__("MessageBlock", llm=llm, memory=memory, simulator=simulator)
         self.agent = agent
         self.description = "Generate and send a message to someone"
         self.find_person_block = FindPersonBlock(llm, memory, simulator)
@@ -219,6 +231,9 @@ class MessageBlock(Block):
         As a {gender} {occupation} with {education} education and {personality} personality,
         generate a message for a friend (relationship strength: {relationship_score}/100)
         about {intention}.
+
+        Your current emotion: {emotion_types}
+        Your current thought: {thought}
         
         Previous chat history:
         {chat_history}
@@ -256,7 +271,7 @@ class MessageBlock(Block):
                     }
                 target = result['target']
             
-            # 使用prompt管理器获取格式化后的提示
+            # Get formatted prompt using prompt manager
             formatted_prompt = await self.prompt_manager.get_prompt(
                 self.memory,
                 step,
@@ -269,7 +284,7 @@ class MessageBlock(Block):
                 message = "Hello! How are you?"
                 
             # Update chat history with proper format
-            chat_histories = await self.memory.get("chat_histories") or {}
+            chat_histories = await self.memory.status.get("chat_histories") or {}
             if not isinstance(chat_histories, dict):
                 chat_histories = {}
             if target not in chat_histories:
@@ -278,23 +293,27 @@ class MessageBlock(Block):
                 chat_histories[target] += "，"
             chat_histories[target] += f"me: {message}"
             
-            await self.memory.update("chat_histories", chat_histories)
+            await self.memory.status.update("chat_histories", chat_histories)
             
             # Send message
             serialized_message = self._serialize_message(message, 1)
+            node_id = await self.memory.stream.add_social(description=f"I sent a message to {target}: {message}")
             return {
                 'success': True,
                 'evaluation': f'Sent message to {target}: {message}',
                 'consumed_time': 10,
                 'message': message,
-                'target': target
+                'target': target,
+                'node_id': node_id
             }
             
         except Exception as e:
+            node_id = await self.memory.stream.add_social(description=f"I can't send a message to {target}")
             return {
                 'success': False,
                 'evaluation': f'Error in sending message: {str(e)}',
-                'consumed_time': 5
+                'consumed_time': 5,
+                'node_id': node_id
             }
         
 class SocialBlock(Block):
@@ -304,10 +323,10 @@ class SocialBlock(Block):
     noneblock: SocialNoneBlock
 
     def __init__(self, agent, llm: LLM, memory: Memory, simulator: Simulator):
-        super().__init__("SocialBlock", llm, memory, simulator)
+        super().__init__("SocialBlock", llm=llm, memory=memory, simulator=simulator)
         self.find_person_block = FindPersonBlock(llm, memory, simulator)
         self.message_block = MessageBlock(agent, llm, memory, simulator)
-        self.noneblock=SocialNoneBlock(llm,memory)
+        self.noneblock=SocialNoneBlock(llm, memory)
         self.dispatcher = BlockDispatcher(llm)
 
         self.trigger_time = 0

pycityagent/cityagent/blocks/utils.py

@@ -8,6 +8,8 @@ Overall plan:
 
 Current action: {intention}
 
+Current emotion: {emotion_types}
+
 Examples:
 - "Learn programming": {{"time": 120}}
 - "Watch a movie": {{"time": 150}} 

pycityagent/cityagent/firmagent.py

@@ -62,12 +62,10 @@ class FirmAgent(InstitutionAgent):
 
     async def forward(self):
         if await self.month_trigger():
-            employees = await self.memory.get("employees")
-            while True:
-                agents_forward = await self.gather_messages(employees, "forward")
-                if np.all(np.array(agents_forward) > self.forward_times):
-                    break
-                await asyncio.sleep(1)
+            employees = await self.memory.status.get("employees")
+            agents_forward = []
+            if not np.all(np.array(agents_forward) > self.forward_times):
+                return
             goods_demand = await self.gather_messages(employees, "goods_demand")
             goods_consumption = await self.gather_messages(
                 employees, "goods_consumption"
@@ -90,6 +88,7 @@ class FirmAgent(InstitutionAgent):
                 await self.send_message_to_agent(
                     uuid,
                     f"work_skill@{max(skill*(1 + np.random.uniform(0, max_change_rate*self.max_wage_inflation)), 1)}",
+                    "economy",
                 )
             price = await self.economy_client.get(self._agent_id, "price")
             await self.economy_client.update(
@@ -109,5 +108,5 @@ class FirmAgent(InstitutionAgent):
             self.forward_times += 1
             for uuid in employees:
                 await self.send_message_to_agent(
-                    uuid, f"firm_forward@{self.forward_times}"
+                    uuid, f"firm_forward@{self.forward_times}", "economy"
                 )

pycityagent/cityagent/governmentagent.py

@@ -53,13 +53,11 @@ class GovernmentAgent(InstitutionAgent):
 
     async def forward(self):
         if await self.month_trigger():
-            citizens = await self.memory.get("citizens")
-            while True:
-                agents_forward = await self.gather_messages(citizens, "forward")
-                if np.all(np.array(agents_forward) > self.forward_times):
-                    break
-                await asyncio.sleep(1)
-            citizens_agent_id = await self.memory.get("citizens_agent_id")
+            citizens = await self.memory.status.get("citizens")
+            agents_forward = await self.gather_messages(citizens, "forward")
+            if not np.all(np.array(agents_forward) > self.forward_times):
+                return
+            citizens_agent_id = await self.memory.status.get("citizens_agent_id")
             incomes = await self.gather_messages(citizens, "income_currency")  # uuid
             _, post_tax_incomes = await self.economy_client.calculate_taxes_due(
                 self._agent_id, citizens_agent_id, incomes, enable_redistribution=False
@@ -68,9 +66,9 @@ class GovernmentAgent(InstitutionAgent):
                 citizens, incomes, post_tax_incomes
             ):
                 tax_paid = income - post_tax_income
-                await self.send_message_to_agent(uuid, f"tax_paid@{tax_paid}")
+                await self.send_message_to_agent(uuid, f"tax_paid@{tax_paid}", "economy")
             self.forward_times += 1
             for uuid in citizens:
                 await self.send_message_to_agent(
-                    uuid, f"government_forward@{self.forward_times}"
+                    uuid, f"government_forward@{self.forward_times}", "economy"
                 )