pycityagent 2.0.0a52__cp310-cp310-macosx_11_0_arm64.whl → 2.0.0a53__cp310-cp310-macosx_11_0_arm64.whl

pycityagent/cityagent/blocks/economy_block.py

@@ -21,20 +21,18 @@ from pycityagent.workflow import Block
 from pycityagent.economy import EconomyClient
 from .utils import *
 import numbers
-import asyncio
 
-
-
-    
 class WorkBlock(Block):
+    """WorkPlace Block"""
     def __init__(self, llm: LLM, memory: Memory, simulator: Simulator):
-        super().__init__("WorkBlock", llm, memory, simulator)
+        super().__init__("WorkBlock", llm=llm, memory=memory, simulator=simulator)
         self.description = "Do work"
         self.guidance_prompt = FormatPrompt(template=TIME_ESTIMATE_PROMPT)
     async def forward(self, step, context):
         self.guidance_prompt.format(
             plan=context['plan'],
-            intention=step['intention']
+            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)
@@ -42,108 +40,94 @@ class WorkBlock(Block):
             result = json.loads(result)
             time = result['time']
             start_time = await self.simulator.get_time(format_time=True)
-            await self.memory.update("working_experience", [f"Start from {start_time}, worked {time} minutes on {step['intention']}"], mode="merge")
-            work_hour_finish = await self.memory.get("work_hour_finish")
+            await self.memory.status.update("working_experience", [f"Start from {start_time}, worked {time} minutes on {step['intention']}"], mode="merge")
+            work_hour_finish = await self.memory.status.get("work_hour_finish")
             work_hour_finish += float(time/60)
-            await self.memory.update("work_hour_finish", work_hour_finish)
+            node_id = await self.memory.stream.add_economy(description=f"I worked {time} minutes on {step['intention']}")
+            await self.memory.status.update("work_hour_finish", work_hour_finish)
             return {
                 'success': True,
-                'evaluation': f'工作：{step["intention"]}',
-                'consumed_time': time
+                'evaluation': f'work: {step["intention"]}',
+                'consumed_time': time,
+                'node_id': node_id
             }
         except Exception as e:
             logger.warning(f"解析时间评估响应时发生错误: {str(e)}, 原始结果: {result}")
             time = random.randint(1, 5)*60
             start_time = await self.simulator.get_time(format_time=True)
-            await self.memory.update("working_experience", [f"Start from {start_time}, worked {time} minutes on {step['intention']}"], mode="merge")
-            work_hour_finish = await self.memory.get("work_hour_finish")
+            await self.memory.status.update("working_experience", [f"Start from {start_time}, worked {time} minutes on {step['intention']}"], mode="merge")
+            work_hour_finish = await self.memory.status.get("work_hour_finish")
+            node_id = await self.memory.stream.add_economy(description=f"I worked {time} minutes on {step['intention']}")
             work_hour_finish += float(time/60)
-            await self.memory.update("work_hour_finish", work_hour_finish)
+            await self.memory.status.update("work_hour_finish", work_hour_finish)
             return {
                 'success': True,
-                'evaluation': f'工作：{step["intention"]}',
-                'consumed_time': time
+                'evaluation': f'work: {step["intention"]}',
+                'consumed_time': time,
+                'node_id': node_id
             }
     
 class ConsumptionBlock(Block):
     """
-    determine the consumption place, time, amount, and items
+    determine the consumption amount, and items
     """
     def __init__(self, llm: LLM, memory: Memory, simulator: Simulator, economy_client: EconomyClient):
-        super().__init__("ConsumptionBlock", llm, memory, simulator)
+        super().__init__("ConsumptionBlock", llm=llm, memory=memory, simulator=simulator)
         self.economy_client = economy_client
         self.forward_times = 0
-        self.description = "Used to determine the consumption place, time, amount, and items"
+        self.description = "Used to determine the consumption amount, and items"
 
     async def forward(self, step, context):
         self.forward_times += 1
-        agent_id = await self.memory.get("id") # agent_id
-        firm_id = await self.memory.get('firm_id')
+        agent_id = await self.memory.status.get("id") # agent_id
+        firm_id = await self.memory.status.get('firm_id')
         intention = step["intention"]
-        nowPlace = await self.memory.get('position')
-        nowPlace = nowPlace['xy_position']
-        nowPlace = (nowPlace['x'], nowPlace['y'])
-        all_poi_types = self.simulator.get_poi_categories(nowPlace, 2000)
-        if len(all_poi_types) == 0:
-            all_poi_types.extend(['supermarket'])
-        prompt = 'Your intention is to {intention}. Which type of POI do you want to go to? Select one and only one type from the following types: {all_poi_types}. Any other output is NOT acceptable.'
-        prompt = FormatPrompt(prompt)
-        prompt.format(intention=intention, all_poi_types=all_poi_types)
-        poi_type = await self.llm.atext_request(prompt.to_dialog(), timeout=300)
-        poi_type = poi_type.strip('[').strip(']')
-        if poi_type not in all_poi_types:
-            poi_type = random.choice(all_poi_types)
-        around_pois = self.simulator.get_around_poi(nowPlace, 2000, poi_type)
-        if len(around_pois) == 0:
-            around_pois.extend(['沃尔玛', '家乐福', '华润万家', '物美'])
-        prompt = """
-                You're a {gender} and your education level is {education}.
-                Your intention is to {intention} and you plan to consume for ${consumption}.
-                The follwing are the places you can go to consume:
-                {around_pois}
-                Where should you go to make a purchase, when should you go, and what items will you spend on?
-                Respond with this format: [place, time, items to buy]. Any other output is NOT acceptable.
-                """
-        prompt = FormatPrompt(prompt)
-        data = {key: await self.memory.get(key) for key in ['gender', 'education']}
-        data['around_pois'] = around_pois
-        data['intention'] = intention
-        month_consumption = await self.memory.get('to_consumption_currency')
-        consumption_currency = await self.memory.get('consumption_currency')
+        month_consumption = await self.memory.status.get('to_consumption_currency')
+        consumption_currency = await self.memory.status.get('consumption_currency')
         if consumption_currency >= month_consumption:
-            return {'Success': True, 'Evaluation': f"Consumption Done", 'consumed_time': 0}
-        data['consumption'] = min(month_consumption/1, month_consumption-consumption_currency)
+            node_id = await self.memory.stream.add_economy(description=f"I have passed the monthly consumption limit, so I will not consume.")
+            return {
+                'success': False, 
+                'evaluation': f"I have passed the monthly consumption limit, so I will not consume.", 
+                'consumed_time': 0,
+                'node_id': node_id
+            }
+        consumption = min(month_consumption/1, month_consumption-consumption_currency)
         price = await self.economy_client.get(firm_id, 'price') # agent_id
         wealth = await self.economy_client.get(agent_id, 'currency')
-        this_demand = int(data['consumption']//price)
+        this_demand = int(consumption//price)
         _, post_consumption_wealth = await self.economy_client.calculate_consumption(firm_id, [agent_id], [this_demand])
         post_consumption_wealth = post_consumption_wealth[0]
-        await self.memory.update('consumption_currency', consumption_currency+wealth-post_consumption_wealth)
-        goods_demand = await self.memory.get('goods_demand')
-        goods_consumption = await self.memory.get('goods_consumption')
-        await self.memory.update('goods_demand', goods_demand+this_demand)
-        await self.memory.update('goods_consumption', goods_consumption+int((wealth-post_consumption_wealth)//price))
-        prompt.format(**data)
-        response = await self.llm.atext_request(prompt.to_dialog(), timeout=300)
-        evaluation = {'success': True, 'evaluation': f"Consumption: {response}", 'consumed_time': 100}
+        await self.memory.status.update('consumption_currency', consumption_currency+wealth-post_consumption_wealth)
+        goods_demand = await self.memory.status.get('goods_demand')
+        goods_consumption = await self.memory.status.get('goods_consumption')
+        await self.memory.status.update('goods_demand', goods_demand+this_demand)
+        await self.memory.status.update('goods_consumption', goods_consumption+int((wealth-post_consumption_wealth)//price))
+        node_id = await self.memory.stream.add_economy(description=f"I bought some goods, and spent {this_demand} on {intention}")
+        evaluation = {
+            'success': True, 
+            'evaluation': f"I bought some goods, and spent {this_demand} on {intention}", 
+            'consumed_time': 20, 
+            'node_id': node_id
+        }
         return evaluation
     
 class EconomyNoneBlock(Block):
     """
-    Do nothing
+    Do anything else
     NoneBlock
     """
     def __init__(self, llm: LLM, memory: Memory):
-        super().__init__("NoneBlock", llm, memory)
-        self.description = "Do nothing"
-        self.forward_times = 0
+        super().__init__("NoneBlock", llm=llm, memory=memory)
+        self.description = "Do anything else"
 
     async def forward(self, step, context):
-        self.forward_times += 1
+        node_id = await self.memory.stream.add_economy(description=f"I {step['intention']}")
         return {
             'success': True,
-            'evaluation': f'完成执行{step["intention"]}',
-            'consumed_time': 0
+            'evaluation': f'Finished{step["intention"]}',
+            'consumed_time': 0,
+            'node_id': node_id
         }
 
 class EconomyBlock(Block):
@@ -152,37 +136,26 @@ class EconomyBlock(Block):
     none_block: EconomyNoneBlock
 
     def __init__(self, llm: LLM, memory: Memory, simulator: Simulator, economy_client: EconomyClient):
-        super().__init__("EconomyBlock", llm, memory, simulator)
+        super().__init__("EconomyBlock", llm=llm, memory=memory, simulator=simulator)
         self.economy_client = economy_client
-        # 初始化所有块
         self.work_block = WorkBlock(llm, memory, simulator)
         self.consumption_block = ConsumptionBlock(llm, memory, simulator, economy_client)
         self.none_block = EconomyNoneBlock(llm, memory)
         self.trigger_time = 0
         self.token_consumption = 0
-        # 初始化调度器
         self.dispatcher = BlockDispatcher(llm)
-        # 注册所有块
         self.dispatcher.register_blocks([self.work_block, self.consumption_block, self.none_block])
 
     async def forward(self, step, context):        
         self.trigger_time += 1
-        consumption_start = self.llm.prompt_tokens_used + self.llm.completion_tokens_used
-
-        # Select the appropriate sub-block using dispatcher
-        # selected_block = await self.dispatcher.dispatch(step)
         selected_block = self.consumption_block
-        
-        # Execute the selected sub-block and get the result
-        result = await selected_block.forward(step, context) # type: ignore
-                
+        result = await selected_block.forward(step, context) # type: ignore  
         return result
     
-# @trigger_class()
 class MonthPlanBlock(Block):
     """Monthly Planning"""
     def __init__(self, llm: LLM, memory: Memory, simulator: Simulator, economy_client: EconomyClient):
-        super().__init__("MonthPlanBlock", llm, memory, simulator)
+        super().__init__("MonthPlanBlock", llm=llm, memory=memory, simulator=simulator)
         self.economy_client = economy_client
         self.llm_error = 0
         self.last_time_trigger = None
@@ -198,26 +171,16 @@ class MonthPlanBlock(Block):
     
     async def forward(self):
         if await self.month_trigger():
-            # while True:
-            #     if self.forward_times == 0:
-            #         break
-            #     firm_forward = await self.memory.get('firm_forward')
-            #     bank_forward = await self.memory.get('bank_forward')
-            #     nbs_forward = await self.memory.get('nbs_forward')
-            #     government_forward = await self.memory.get('government_forward')
-            #     if self.forward_times <= firm_forward and self.forward_times <= bank_forward and self.forward_times <= nbs_forward and self.forward_times <= government_forward:
-            #         break
-            #     await asyncio.sleep(1)
-            agent_id = await self.memory.get("id")
-            firm_id = await self.memory.get('firm_id')
-            bank_id = await self.memory.get('bank_id')
-            name = await self.memory.get('name')
-            age = await self.memory.get('age')
-            city = await self.memory.get('city')
-            job = await self.memory.get('occupation')
-            skill = await self.memory.get('work_skill')
-            consumption = await self.memory.get('consumption_currency')
-            tax_paid = await self.memory.get('tax_paid')
+            agent_id = await self.memory.status.get("id")
+            firm_id = await self.memory.status.get('firm_id')
+            bank_id = await self.memory.status.get('bank_id')
+            name = await self.memory.status.get('name')
+            age = await self.memory.status.get('age')
+            city = await self.memory.status.get('city')
+            job = await self.memory.status.get('occupation')
+            skill = await self.memory.status.get('work_skill')
+            consumption = await self.memory.status.get('consumption_currency')
+            tax_paid = await self.memory.status.get('tax_paid')
             price = await self.economy_client.get(firm_id, 'price')
             wealth = await self.economy_client.get(agent_id, 'currency')
             interest_rate = await self.economy_client.get(bank_id, 'interest_rate')
@@ -228,7 +191,7 @@ class MonthPlanBlock(Block):
             job_prompt = f'''
                         In the previous month, you worked as a(an) {job}. If you continue working this month, your expected hourly income will be ${skill:.2f}.
                     '''
-            consumption_propensity = await self.memory.get('consumption_propensity')
+            consumption_propensity = await self.memory.status.get('consumption_propensity')
             if (consumption <= 0) and (consumption_propensity > 0):
                 consumption_prompt = f'''
                             Besides, you had no consumption due to shortage of goods.
@@ -238,7 +201,7 @@ class MonthPlanBlock(Block):
                             Besides, your consumption was ${consumption:.2f}.
                         '''
             tax_prompt = f'''Your tax deduction amounted to ${tax_paid:.2f}, and the government uses the tax revenue to provide social services to all citizens.'''
-            if UBI:
+            if UBI and self.forward_times >= 96:
                 tax_prompt = f'{tax_prompt} Specifically, the government directly provides ${UBI} per capita in each month.'
             price_prompt = f'''Meanwhile, in the consumption market, the average price of essential goods is now at ${price:.2f}.'''
             job_prompt = prettify_document(job_prompt)
@@ -254,41 +217,42 @@ class MonthPlanBlock(Block):
                             Any other output words are NOT allowed.
                         '''
             obs_prompt = prettify_document(obs_prompt)
-            await self.memory.update('dialog_queue', [{'role': 'user', 'content': obs_prompt}], mode='merge')
-            dialog_queue = await self.memory.get('dialog_queue')
+            await self.memory.status.update('dialog_queue', [{'role': 'user', 'content': obs_prompt}], mode='merge')
+            dialog_queue = await self.memory.status.get('dialog_queue')
             content = await self.llm.atext_request(list(dialog_queue), timeout=300)
-            await self.memory.update('dialog_queue', [{'role': 'assistant', 'content': content}], mode='merge')
+            await self.memory.status.update('dialog_queue', [{'role': 'assistant', 'content': content}], mode='merge')
             try:
                 propensity_dict = extract_dict_from_string(content)[0]
                 work_propensity, consumption_propensity = propensity_dict['work'], propensity_dict['consumption']
                 if isinstance(work_propensity, numbers.Number) and isinstance(consumption_propensity, numbers.Number):
-                    await self.memory.update('work_propensity', work_propensity)
-                    await self.memory.update('consumption_propensity', consumption_propensity)
+                    await self.memory.status.update('work_propensity', work_propensity)
+                    await self.memory.status.update('consumption_propensity', consumption_propensity)
                 else:
                     self.llm_error += 1
             except:
                 self.llm_error += 1
                 
-            skill = await self.memory.get('work_skill')
-            work_propensity = await self.memory.get('work_propensity')
-            consumption_propensity = await self.memory.get('consumption_propensity')
+            skill = await self.memory.status.get('work_skill')
+            work_propensity = await self.memory.status.get('work_propensity')
+            consumption_propensity = await self.memory.status.get('consumption_propensity')
             work_hours = work_propensity * num_labor_hours
-            await self.memory.update('income_currency', work_hours * skill)
+            await self.memory.status.update('income_currency', work_hours * skill)
             wealth = await self.economy_client.get(agent_id, 'currency')
             await self.economy_client.update(agent_id, 'currency', wealth + work_hours * skill)
             await self.economy_client.add_delta_value(firm_id, 'inventory', int(work_hours*productivity_per_labor))
             
-            income_currency = await self.memory.get('income_currency')
-            await self.memory.update('income_currency', income_currency + UBI)
-            wealth = await self.economy_client.get(agent_id, 'currency')
-            await self.economy_client.update(agent_id, 'currency', wealth + UBI)
+            if UBI and self.forward_times >= 96:
+                income_currency = await self.memory.status.get('income_currency')
+                await self.memory.status.update('income_currency', income_currency + UBI)
+                wealth = await self.economy_client.get(agent_id, 'currency')
+                await self.economy_client.update(agent_id, 'currency', wealth + UBI)
 
             wealth = await self.economy_client.get(agent_id, 'currency')
-            await self.memory.update('to_consumption_currency', consumption_propensity*wealth)
+            await self.memory.status.update('to_consumption_currency', consumption_propensity*wealth)
             
-            await self.memory.update('consumption_currency', 0)
-            await self.memory.update('goods_demand', 0)
-            await self.memory.update('goods_consumption', 0)
+            await self.memory.status.update('consumption_currency', 0)
+            await self.memory.status.update('goods_demand', 0)
+            await self.memory.status.update('goods_consumption', 0)
             
             if self.forward_times % 3 == 0:
                 obs_prompt = f'''
@@ -335,11 +299,11 @@ class MonthPlanBlock(Block):
                         else:
                             content[k] = category2score[content[k].lower()]
                     depression = sum(list(content.values()))
-                    await self.memory.update('depression', depression)
+                    await self.memory.status.update('depression', depression)
                 except:
                     self.llm_error += 1
 
-            if UBI and self.forward_times % 12:
+            if UBI and self.forward_times >= 96 and self.forward_times % 12:
                 obs_prompt = f'''
                                 {problem_prompt} {job_prompt} {consumption_prompt} {tax_prompt} {price_prompt}
                                 Your current savings account balance is ${wealth:.2f}. Interest rates, as set by your bank, stand at {interest_rate*100:.2f}%. 
@@ -347,10 +311,7 @@ class MonthPlanBlock(Block):
                             '''
                 obs_prompt = prettify_document(obs_prompt)
                 content = await self.llm.atext_request([{'role': 'user', 'content': obs_prompt}], timeout=300)
-                await self.memory.update('ubi_opinion', [content], mode='merge')
-                ubi_opinion = await self.memory.get('ubi_opinion')
-                with open(f'/data1/linian/SocietySim/socialcity-agent-zoo/ubi_opinions/{agent_id}.pkl', 'wb') as f:
-                    pkl.dump(ubi_opinion, f)
+                await self.memory.status.update('ubi_opinion', [content], mode='merge')
 
             self.forward_times += 1
-            await self.memory.update('forward', self.forward_times)
+            await self.memory.status.update('forward', self.forward_times)

pycityagent/cityagent/blocks/mobility_block.py

@@ -1,8 +1,8 @@
 from typing import List
 from .dispatcher import BlockDispatcher
 from pycityagent.environment.simulator import Simulator
-from pycityagent.llm.llm import LLM
-from pycityagent.memory.memory import Memory
+from pycityagent.llm import LLM
+from pycityagent.memory import Memory
 from pycityagent.workflow.block import Block
 import random
 import logging
@@ -31,25 +31,32 @@ User requirement: {intention}
 Your output must be a single selection from ['home', 'workplace', 'other'] without any additional text or explanation.
 """
 
+RADIUS_PROMPT = """As an intelligent decision system, please determine the maximum travel radius (in meters) based on the current emotional state.
+
+Your current emotion: {emotion_types}
+Your current thought: {thought}
+
+Please analyze how these emotions would affect travel willingness and return only a single integer number between 1000-100000 representing the maximum travel radius in meters. A more positive emotional state generally leads to greater willingness to travel further.
+
+Return only the integer number without any additional text or explanation."""
+
 class PlaceSelectionBlock(Block):
     """
     选择目的地
     PlaceSelectionBlock
     """
-    configurable_fields: List[str] = ["search_radius", "search_limit"]
+    configurable_fields: List[str] = ["search_limit"]
     default_values = {
-        "search_radius": 100000,
         "search_limit": 10
     }
 
     def __init__(self, llm: LLM, memory: Memory, simulator: Simulator):
-        super().__init__("PlaceSelectionBlock", llm, memory, simulator)
+        super().__init__("PlaceSelectionBlock", llm=llm, memory=memory, simulator=simulator)
         self.description = "Used to select and determine destinations for unknown locations (excluding home and workplace), such as choosing specific shopping malls, restaurants and other places"
         self.typeSelectionPrompt = FormatPrompt(PLACE_TYPE_SELECTION_PROMPT)
         self.secondTypeSelectionPrompt = FormatPrompt(PLACE_SECOND_TYPE_SELECTION_PROMPT)
-
+        self.radiusPrompt = FormatPrompt(RADIUS_PROMPT)
         # configurable fields
-        self.search_radius = 100000
         self.search_limit = 10
 
     async def forward(self, step, context):
@@ -71,13 +78,18 @@ class PlaceSelectionBlock(Block):
             poi_category = sub_category
         )
         levelTwoType = await self.llm.atext_request(self.secondTypeSelectionPrompt.to_dialog()) # type: ignore
-        center = await self.memory.get('position')
+        center = await self.memory.status.get('position')
         center = (center['xy_position']['x'], center['xy_position']['y'])
+        self.radiusPrompt.format(
+            emotion_types=await self.memory.status.get("emotion_types"),
+            thought=await self.memory.status.get("thought")
+        )
+        radius = int(await self.llm.atext_request(self.radiusPrompt.to_dialog())) # type: ignore
         try:
             pois = self.simulator.map.query_pois(
                 center = center,
                 category_prefix = levelTwoType,
-                radius=self.search_radius,
+                radius=radius,
                 limit=self.search_limit
             )
         except Exception as e:
@@ -86,7 +98,7 @@ class PlaceSelectionBlock(Block):
             pois = self.simulator.map.query_pois(
                 center = center,
                 category_prefix = levelTwoType,
-                radius=self.search_radius,
+                radius=radius,
                 limit=self.search_limit
             )
         if len(pois) > 0:
@@ -94,11 +106,12 @@ class PlaceSelectionBlock(Block):
             nextPlace = (poi['name'], poi['aoi_id'])
             # 将地点信息保存到context中
             context['next_place'] = nextPlace
-            # 这里应该添加选择地点的具体逻辑
+            node_id = await self.memory.stream.add_mobility(description=f"For {step['intention']}, I selected the destination: {nextPlace}")
             return {
                 'success': True,
                 'evaluation': f'Successfully selected the destination: {nextPlace}',
-                'consumed_time': 5
+                'consumed_time': 5,
+                'node_id': node_id
             }
         else:
             simmap = self.simulator.map
@@ -106,11 +119,12 @@ class PlaceSelectionBlock(Block):
             nextPlace = (poi['name'], poi['aoi_id'])
             # 将地点信息保存到context中
             context['next_place'] = nextPlace
-            # 这里应该添加选择地点的具体逻辑
+            node_id = await self.memory.stream.add_mobility(description=f"For {step['intention']}, I selected the destination: {nextPlace}")
             return {
                 'success': True,
                 'evaluation': f'Successfully selected the destination: {nextPlace}',
-                'consumed_time': 5
+                'consumed_time': 5,
+                'node_id': node_id
             }
 
 class MoveBlock(Block):
@@ -119,30 +133,35 @@ class MoveBlock(Block):
     MoveBlock
     """
     def __init__(self, llm: LLM, memory: Memory, simulator: Simulator):
-        super().__init__("MoveBlock", llm, memory, simulator)
+        super().__init__("MoveBlock", llm=llm, memory=memory, simulator=simulator)
         self.description = "Used to execute specific mobility operations, such as returning home, going to work, or visiting a specific location"
         self.placeAnalysisPrompt = FormatPrompt(PLACE_ANALYSIS_PROMPT)
 
     async def forward(self, step, context):
         # 这里应该添加移动的具体逻辑
-        agent_id = await self.memory.get("id")
+        agent_id = await self.memory.status.get("id")
         self.placeAnalysisPrompt.format(
             plan = context['plan'],
             intention = step["intention"]
         )
+        number_poi_visited = await self.memory.status.get("number_poi_visited")
+        number_poi_visited += 1
+        await self.memory.status.update("number_poi_visited", number_poi_visited)
         response = await self.llm.atext_request(self.placeAnalysisPrompt.to_dialog()) # type: ignore
         if response == 'home':
             # 返回到家
-            home = await self.memory.get('home')
+            home = await self.memory.status.get('home')
             home = home['aoi_position']['aoi_id']
-            nowPlace = await self.memory.get('position')
+            nowPlace = await self.memory.status.get('position')
+            node_id = await self.memory.stream.add_mobility(description=f"I returned home")
             if 'aoi_position' in nowPlace and nowPlace['aoi_position']['aoi_id'] == home:
                 return {
                     'success': True,
                     'evaluation': f'Successfully returned home (already at home)',
                     'from_place': home,
                     'to_place': home,
-                    'consumed_time': 0
+                    'consumed_time': 0,
+                    'node_id': node_id
                 }
             await self.simulator.set_aoi_schedules(
                 person_id=agent_id,
@@ -153,20 +172,23 @@ class MoveBlock(Block):
                 'evaluation': f'Successfully returned home',
                 'from_place': nowPlace['aoi_position']['aoi_id'],
                 'to_place': home,
-                'consumed_time': 45
+                'consumed_time': 45,
+                'node_id': node_id
             }
         elif response == 'workplace':
             # 返回到工作地点
-            work = await self.memory.get('work')
+            work = await self.memory.status.get('work')
             work = work['aoi_position']['aoi_id']
-            nowPlace = await self.memory.get('position')
+            nowPlace = await self.memory.status.get('position')
+            node_id = await self.memory.stream.add_mobility(description=f"I went to my workplace")
             if 'aoi_position' in nowPlace and nowPlace['aoi_position']['aoi_id'] == work:
                 return {
                     'success': True,
                     'evaluation': f'Successfully reached the workplace (already at the workplace)',
                     'from_place': work,
                     'to_place': work,
-                    'consumed_time': 0
+                    'consumed_time': 0,
+                    'node_id': node_id
                 }
             await self.simulator.set_aoi_schedules(
                 person_id=agent_id,
@@ -177,12 +199,14 @@ class MoveBlock(Block):
                 'evaluation': f'Successfully reached the workplace',
                 'from_place': nowPlace['aoi_position']['aoi_id'],
                 'to_place': work,
-                'consumed_time': 45
+                'consumed_time': 45,
+                'node_id': node_id
             }
         else:
             # 移动到其他地点
             next_place = context.get('next_place', None)
-            nowPlace = await self.memory.get('position')
+            nowPlace = await self.memory.status.get('position')
+            node_id = await self.memory.stream.add_mobility(description=f"I went to {next_place}")
             if next_place != None:
                 await self.simulator.set_aoi_schedules(
                     person_id=agent_id,
@@ -205,7 +229,8 @@ class MoveBlock(Block):
                 'evaluation': f'Successfully reached the destination: {next_place}',
                 'from_place': nowPlace['aoi_position']['aoi_id'],
                 'to_place': next_place[1],
-                'consumed_time': 45
+                'consumed_time': 45,
+                'node_id': node_id
             }
     
 class MobilityNoneBlock(Block):
@@ -214,14 +239,16 @@ class MobilityNoneBlock(Block):
     MobilityNoneBlock
     """
     def __init__(self, llm: LLM, memory: Memory):
-        super().__init__("MobilityNoneBlock", llm, memory)
+        super().__init__("MobilityNoneBlock", llm=llm, memory=memory)
         self.description = "Used to handle other cases"
 
     async def forward(self, step, context):
+        node_id = await self.memory.stream.add_mobility(description=f"I finished {step['intention']}")
         return {
             'success': True,
             'evaluation': f'Finished executing {step["intention"]}',
-            'consumed_time': 0
+            'consumed_time': 0,
+            'node_id': node_id
         }
 
 class MobilityBlock(Block):
@@ -230,7 +257,7 @@ class MobilityBlock(Block):
     mobility_none_block: MobilityNoneBlock
 
     def __init__(self, llm: LLM, memory: Memory, simulator: Simulator):
-        super().__init__("MobilityBlock", llm, memory, simulator)
+        super().__init__("MobilityBlock", llm=llm, memory=memory, simulator=simulator)
         # 初始化所有块
         self.place_selection_block = PlaceSelectionBlock(llm, memory, simulator)
         self.move_block = MoveBlock(llm, memory, simulator)