pycityagent 2.0.0a47__cp311-cp311-macosx_11_0_arm64.whl → 2.0.0a49__cp311-cp311-macosx_11_0_arm64.whl

pycityagent/cityagent/blocks/economy_block.py

@@ -0,0 +1,356 @@
+import json
+import random
+from pycityagent.llm.llm import LLM
+from pycityagent.workflow.block import Block
+from pycityagent.memory import Memory
+
+from .utils import clean_json_response, TIME_ESTIMATE_PROMPT
+
+from .dispatcher import BlockDispatcher
+from pycityagent.environment.simulator import Simulator
+from pycityagent.llm import LLM
+from pycityagent.memory import Memory
+from pycityagent.workflow import Block
+import random
+import logging
+logger = logging.getLogger("pycityagent")
+import pickle as pkl
+
+from pycityagent.workflow.prompt import FormatPrompt
+from pycityagent.workflow import Block
+from pycityagent.economy import EconomyClient
+from .utils import *
+import numbers
+import asyncio
+
+
+
+    
+class WorkBlock(Block):
+    def __init__(self, llm: LLM, memory: Memory, simulator: Simulator):
+        super().__init__("WorkBlock", llm, memory, 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']
+        )
+        result = await self.llm.atext_request(self.guidance_prompt.to_dialog())
+        result = clean_json_response(result)
+        try:
+            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")
+            work_hour_finish += float(time/60)
+            await self.memory.update("work_hour_finish", work_hour_finish)
+            return {
+                'success': True,
+                'evaluation': f'工作：{step["intention"]}',
+                'consumed_time': time
+            }
+        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")
+            work_hour_finish += float(time/60)
+            await self.memory.update("work_hour_finish", work_hour_finish)
+            return {
+                'success': True,
+                'evaluation': f'工作：{step["intention"]}',
+                'consumed_time': time
+            }
+    
+class ConsumptionBlock(Block):
+    """
+    determine the consumption place, time, amount, and items
+    """
+    def __init__(self, llm: LLM, memory: Memory, simulator: Simulator, economy_client: EconomyClient):
+        super().__init__("ConsumptionBlock", llm, memory, simulator)
+        self.economy_client = economy_client
+        self.forward_times = 0
+        self.description = "Used to determine the consumption place, time, 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')
+        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')
+        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)
+        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)
+        _, 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}
+        return evaluation
+    
+class EconomyNoneBlock(Block):
+    """
+    Do nothing
+    NoneBlock
+    """
+    def __init__(self, llm: LLM, memory: Memory):
+        super().__init__("NoneBlock", llm, memory)
+        self.description = "Do nothing"
+        self.forward_times = 0
+
+    async def forward(self, step, context):
+        self.forward_times += 1
+        return {
+            'success': True,
+            'evaluation': f'完成执行{step["intention"]}',
+            'consumed_time': 0
+        }
+
+class EconomyBlock(Block):
+    work_block: WorkBlock
+    consumption_block: ConsumptionBlock
+    none_block: EconomyNoneBlock
+
+    def __init__(self, llm: LLM, memory: Memory, simulator: Simulator, economy_client: EconomyClient):
+        super().__init__("EconomyBlock", llm, memory, 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
+                
+        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)
+        self.economy_client = economy_client
+        self.llm_error = 0
+        self.last_time_trigger = None
+        self.time_diff = month_days * 24 * 60 * 60
+        self.forward_times = 0
+        
+    async def month_trigger(self):
+        now_time = await self.simulator.get_time()
+        if self.last_time_trigger is None or now_time - self.last_time_trigger >= self.time_diff:
+            self.last_time_trigger = now_time
+            return True
+        return False
+    
+    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')
+            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')
+            
+            problem_prompt = f'''
+                    You're {name}, a {age}-year-old individual living in {city}. As with all Americans, a portion of your monthly income is taxed by the federal government. This taxation system is tiered, income is taxed cumulatively within defined brackets, combined with a redistributive policy: after collection, the government evenly redistributes the tax revenue back to all citizens, irrespective of their earnings.
+                '''
+            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')
+            if (consumption <= 0) and (consumption_propensity > 0):
+                consumption_prompt = f'''
+                            Besides, you had no consumption due to shortage of goods.
+                        '''
+            else:
+                consumption_prompt = f'''
+                            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:
+                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)
+            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}%. 
+                            Your goal is to maximize your utility by deciding how much to work and how much to consume. Your utility is determined by your consumption, income, saving, social service recieved and leisure time. You will spend the time you do not work on leisure activities. 
+                            With all these factors in play, and considering aspects like your living costs, any future aspirations, and the broader economic trends, how is your willingness to work this month? Furthermore, how would you plan your expenditures on essential goods, keeping in mind good price?
+                            Please share your decisions in a JSON format as follows:
+                            {{'work': a value between 0 and 1, indicating the propensity to work,
+                            'consumption': a value between 0 and 1, indicating the proportion of all your savings and income you intend to spend on essential goods
+                            }}
+                            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')
+            content = await self.llm.atext_request(list(dialog_queue), timeout=300)
+            await self.memory.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)
+                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')
+            work_hours = work_propensity * num_labor_hours
+            await self.memory.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)
+
+            wealth = await self.economy_client.get(agent_id, 'currency')
+            await self.memory.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)
+            
+            if self.forward_times % 3 == 0:
+                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}%. 
+                                Please fill in the following questionnaire:
+                                Indicate how often you have felt this way during the last week by choosing one of the following options:
+                                "Rarely" means Rarely or none of the time (less than 1 day),
+                                "Some" means Some or a little of the time (1-2 days),
+                                "Occasionally" means Occasionally or a moderate amount of the time (3-4 days),
+                                "Most" means Most or all of the time (5-7 days).
+                                Statement 1: I was bothered by things that usually don't bother me.  
+                                Statement 2: I did not feel like eating; my appetite was poor.
+                                Statement 3: I felt that I could not shake off the blues even with help from my family or friends.
+                                Statement 4: I felt that I was just as good as other people.
+                                Statement 5: I had trouble keeping my mind on what I was doing.
+                                Statement 6: I felt depressed.
+                                Statement 7: I felt that everything I did was an effort.
+                                Statement 8: I felt hopeful about the future.
+                                Statement 9: I thought my life had been a failure.
+                                Statement 10: I felt fearful.
+                                Statement 11: My sleep was restless.
+                                Statement 12: I was happy.
+                                Statement 13: I talked less than usual.
+                                Statement 14: I felt lonely.
+                                Statement 15: People were unfriendly.
+                                Statement 16: I enjoyed life.
+                                Statement 17: I had crying spells.
+                                Statement 18: I felt sad.
+                                Statement 19: I felt that people disliked me.
+                                Statement 20: I could not get "going".
+                                Please response with json format with keys being numbers 1-20 and values being one of "Rarely", "Some", "Occasionally", "Most".
+                                Any other output words are NOT allowed.
+                            '''
+                obs_prompt = prettify_document(obs_prompt)
+                content = await self.llm.atext_request([{'role': 'user', 'content': obs_prompt}], timeout=300)
+                inverse_score_items = [3, 8, 12, 16]
+                category2score = {'rarely': 0, 'some': 1, 'occasionally': 2, 'most': 3}
+                try:
+                    content = extract_dict_from_string(content)[0]
+                    for k in content:
+                        if k in inverse_score_items:
+                            content[k] = 3 - category2score[content[k].lower()]
+                        else:
+                            content[k] = category2score[content[k].lower()]
+                    depression = sum(list(content.values()))
+                    await self.memory.update('depression', depression)
+                except:
+                    self.llm_error += 1
+
+            if UBI 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}%. 
+                                What's your opinion on the UBI policy, including the advantages and disadvantages?
+                            '''
+                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)
+
+            self.forward_times += 1
+            await self.memory.update('forward', self.forward_times)

pycityagent/cityagent/blocks/mobility_block.py

@@ -0,0 +1,258 @@
+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.workflow.block import Block
+import random
+import logging
+logger = logging.getLogger("pycityagent")
+from pycityagent.workflow.prompt import FormatPrompt
+
+PLACE_TYPE_SELECTION_PROMPT = """
+As an intelligent decision system, please determine the type of place the user needs to visit based on their input requirement.
+User Plan: {plan}
+User requirement: {intention}
+Your output must be a single selection from {poi_category} without any additional text or explanation.
+"""
+
+PLACE_SECOND_TYPE_SELECTION_PROMPT = """
+As an intelligent decision system, please determine the type of place the user needs to visit based on their input requirement.
+User Plan: {plan}
+User requirement: {intention}
+Your output must be a single selection from {poi_category} without any additional text or explanation.
+"""
+
+PLACE_ANALYSIS_PROMPT = """
+As an intelligent analysis system, please determine the type of place the user needs to visit based on their input requirement.
+User Plan: {plan}
+User requirement: {intention}
+
+Your output must be a single selection from ['home', 'workplace', 'other'] without any additional text or explanation.
+"""
+
+class PlaceSelectionBlock(Block):
+    """
+    选择目的地
+    PlaceSelectionBlock
+    """
+    configurable_fields: List[str] = ["search_radius", "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)
+        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)
+
+        # configurable fields
+        self.search_radius = 100000
+        self.search_limit = 10
+
+    async def forward(self, step, context):
+        self.typeSelectionPrompt.format(
+            plan = context['plan'],
+            intention = step['intention'],
+            poi_category = list(self.simulator.poi_cate.keys())
+        )
+        levelOneType = await self.llm.atext_request(self.typeSelectionPrompt.to_dialog()) # type: ignore
+        try:
+            sub_category = self.simulator.poi_cate[levelOneType]
+        except Exception as e:
+            logger.warning(f"Wrong type of poi, raw response: {levelOneType}")
+            levelOneType = random.choice(list(self.simulator.poi_cate.keys()))
+            sub_category = self.simulator.poi_cate[levelOneType]
+        self.secondTypeSelectionPrompt.format(
+            plan = context['plan'],
+            intention = step['intention'],
+            poi_category = sub_category
+        )
+        levelTwoType = await self.llm.atext_request(self.secondTypeSelectionPrompt.to_dialog()) # type: ignore
+        center = await self.memory.get('position')
+        center = (center['xy_position']['x'], center['xy_position']['y'])
+        try:
+            pois = self.simulator.map.query_pois(
+                center = center,
+                category_prefix = levelTwoType,
+                radius=self.search_radius,
+                limit=self.search_limit
+            )
+        except Exception as e:
+            logger.warning(f"Error querying pois: {e}")
+            levelTwoType = random.choice(sub_category)
+            pois = self.simulator.map.query_pois(
+                center = center,
+                category_prefix = levelTwoType,
+                radius=self.search_radius,
+                limit=self.search_limit
+            )
+        if len(pois) > 0:
+            poi = random.choice(pois)[0]
+            nextPlace = (poi['name'], poi['aoi_id'])
+            # 将地点信息保存到context中
+            context['next_place'] = nextPlace
+            # 这里应该添加选择地点的具体逻辑
+            return {
+                'success': True,
+                'evaluation': f'Successfully selected the destination: {nextPlace}',
+                'consumed_time': 5
+            }
+        else:
+            simmap = self.simulator.map
+            poi = random.choice(list(simmap.pois.values()))
+            nextPlace = (poi['name'], poi['aoi_id'])
+            # 将地点信息保存到context中
+            context['next_place'] = nextPlace
+            # 这里应该添加选择地点的具体逻辑
+            return {
+                'success': True,
+                'evaluation': f'Successfully selected the destination: {nextPlace}',
+                'consumed_time': 5
+            }
+
+class MoveBlock(Block):
+    """
+    移动操作
+    MoveBlock
+    """
+    def __init__(self, llm: LLM, memory: Memory, simulator: Simulator):
+        super().__init__("MoveBlock", llm, memory, 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")
+        self.placeAnalysisPrompt.format(
+            plan = context['plan'],
+            intention = step["intention"]
+        )
+        response = await self.llm.atext_request(self.placeAnalysisPrompt.to_dialog()) # type: ignore
+        if response == 'home':
+            # 返回到家
+            home = await self.memory.get('home')
+            home = home['aoi_position']['aoi_id']
+            nowPlace = await self.memory.get('position')
+            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
+                }
+            await self.simulator.set_aoi_schedules(
+                person_id=agent_id,
+                target_positions=home,
+            )
+            return {
+                'success': True,
+                'evaluation': f'Successfully returned home',
+                'from_place': nowPlace['aoi_position']['aoi_id'],
+                'to_place': home,
+                'consumed_time': 45
+            }
+        elif response == 'workplace':
+            # 返回到工作地点
+            work = await self.memory.get('work')
+            work = work['aoi_position']['aoi_id']
+            nowPlace = await self.memory.get('position')
+            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
+                }
+            await self.simulator.set_aoi_schedules(
+                person_id=agent_id,
+                target_positions=work,
+            )
+            return {
+                'success': True,
+                'evaluation': f'Successfully reached the workplace',
+                'from_place': nowPlace['aoi_position']['aoi_id'],
+                'to_place': work,
+                'consumed_time': 45
+            }
+        else:
+            # 移动到其他地点
+            next_place = context.get('next_place', None)
+            nowPlace = await self.memory.get('position')
+            if next_place != None:
+                await self.simulator.set_aoi_schedules(
+                    person_id=agent_id,
+                    target_positions=next_place[1],
+                )
+            else:
+                while True:
+                    r_aoi = random.choice(list(self.simulator.map.aois.values()))
+                    if len(r_aoi['poi_ids']) > 0:
+                        r_poi = random.choice(r_aoi['poi_ids'])
+                        break
+                poi = self.simulator.map.pois[r_poi]
+                next_place = (poi['name'], poi['aoi_id'])
+                await self.simulator.set_aoi_schedules(
+                    person_id=agent_id,
+                    target_positions=next_place[1],
+                )
+            return {
+                'success': True,
+                'evaluation': f'Successfully reached the destination: {next_place}',
+                'from_place': nowPlace['aoi_position']['aoi_id'],
+                'to_place': next_place[1],
+                'consumed_time': 45
+            }
+    
+class MobilityNoneBlock(Block):
+    """
+    空操作
+    MobilityNoneBlock
+    """
+    def __init__(self, llm: LLM, memory: Memory):
+        super().__init__("MobilityNoneBlock", llm, memory)
+        self.description = "Used to handle other cases"
+
+    async def forward(self, step, context):
+        return {
+            'success': True,
+            'evaluation': f'Finished executing {step["intention"]}',
+            'consumed_time': 0
+        }
+
+class MobilityBlock(Block):
+    place_selection_block: PlaceSelectionBlock
+    move_block: MoveBlock
+    mobility_none_block: MobilityNoneBlock
+
+    def __init__(self, llm: LLM, memory: Memory, simulator: Simulator):
+        super().__init__("MobilityBlock", llm, memory, simulator)
+        # 初始化所有块
+        self.place_selection_block = PlaceSelectionBlock(llm, memory, simulator)
+        self.move_block = MoveBlock(llm, memory, simulator)
+        self.mobility_none_block = MobilityNoneBlock(llm, memory)
+        self.trigger_time = 0
+        self.token_consumption = 0
+        # 初始化调度器
+        self.dispatcher = BlockDispatcher(llm)
+        # 注册所有块
+        self.dispatcher.register_blocks([self.place_selection_block, self.move_block, self.mobility_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)
+        
+        # Execute the selected sub-block and get the result
+        result = await selected_block.forward(step, context) # type: ignore
+
+        consumption_end = self.llm.prompt_tokens_used + self.llm.completion_tokens_used
+        self.token_consumption += consumption_end - consumption_start
+        
+        return result