pycityagent 2.0.0a46__cp312-cp312-macosx_11_0_arm64.whl → 2.0.0a48__cp312-cp312-macosx_11_0_arm64.whl

pycityagent/__init__.py

@@ -4,8 +4,9 @@ Pycityagent: 城市智能体构建框架
 
 from .agent import Agent, CitizenAgent, InstitutionAgent
 from .environment import Simulator
-import logging
 from .llm import SentenceEmbedding
+from .simulation import AgentSimulation
+import logging
 
 # 创建一个 pycityagent 记录器
 logger = logging.getLogger("pycityagent")
@@ -20,4 +21,4 @@ if not logger.hasHandlers():
     handler.setFormatter(formatter)
     logger.addHandler(handler)
 
-__all__ = ["Agent", "Simulator", "CitizenAgent", "InstitutionAgent","SentenceEmbedding",]
+__all__ = ["Agent", "Simulator", "CitizenAgent", "InstitutionAgent","SentenceEmbedding","AgentSimulation"]

pycityagent/agent.py

@@ -1,6 +1,6 @@
-"""智能体模板类及其定义"""
-
+from __future__ import annotations
 import asyncio
+import inspect
 import json
 import logging
 import random
@@ -9,14 +9,17 @@ from abc import ABC, abstractmethod
 from copy import deepcopy
 from datetime import datetime, timezone
 from enum import Enum
-from typing import Any, Optional
+from typing import Any, List, Optional, Type, get_type_hints
 from uuid import UUID
 
 import fastavro
+from pyparsing import Dict
 import ray
 from mosstool.util.format_converter import dict2pb
 from pycityproto.city.person.v2 import person_pb2 as person_pb2
 
+from pycityagent.workflow import Block
+
 from .economy import EconomyClient
 from .environment import Simulator
 from .environment.sim.person_service import PersonService
@@ -46,6 +49,8 @@ class Agent(ABC):
     """
     Agent base class
     """
+    configurable_fields: List[str] = []
+    default_values: dict[str, Any] = {}
 
     def __init__(
         self,
@@ -101,6 +106,98 @@ class Agent(ABC):
         del state["_llm_client"]
         return state
 
+    @classmethod
+    def export_class_config(cls) -> Dict[str, Dict]:
+        result = {
+            "agent_name": cls.__name__,
+            "config": {},
+            "blocks": []
+        }
+        config = {
+            field: cls.default_values.get(field, "default_value")
+            for field in cls.configurable_fields
+        }
+        result["config"] = config
+        # 解析类中的注解，找到Block类型的字段
+        hints = get_type_hints(cls)
+        for attr_name, attr_type in hints.items():
+            if inspect.isclass(attr_type) and issubclass(attr_type, Block):
+                block_config = attr_type.export_class_config()
+                result["blocks"].append({
+                    "name": attr_name,
+                    "config": block_config,
+                    "children": cls._export_subblocks(attr_type)
+                })
+        return result
+
+    @classmethod
+    def _export_subblocks(cls, block_cls: Type[Block]) -> List[Dict]:
+        children = []
+        hints = get_type_hints(block_cls)  # 获取类的注解
+        for attr_name, attr_type in hints.items():
+            if inspect.isclass(attr_type) and issubclass(attr_type, Block):
+                block_config = attr_type.export_class_config()
+                children.append({
+                    "name": attr_name,
+                    "config": block_config,
+                    "children": cls._export_subblocks(attr_type)
+                })
+        return children
+
+    @classmethod
+    def export_to_file(cls, filepath: str) -> None:
+        config = cls.export_class_config()
+        with open(filepath, "w") as f:
+            json.dump(config, f, indent=4)
+
+    @classmethod
+    def import_block_config(cls, config: Dict[str, List[Dict]]) -> "Agent":
+        agent = cls(name=config["agent_name"])
+
+        def build_block(block_data: Dict) -> Block:
+            block_cls = globals()[block_data["name"]]
+            block_instance = block_cls.import_config(block_data)
+            return block_instance
+
+        # 创建顶层Block
+        for block_data in config["blocks"]:
+            block = build_block(block_data)
+            setattr(agent, block.name.lower(), block)
+
+        return agent
+
+    @classmethod
+    def import_from_file(cls, filepath: str) -> "Agent":
+        with open(filepath, "r") as f:
+            config = json.load(f)
+            return cls.import_block_config(config)
+        
+    def load_from_config(self, config: Dict[str, List[Dict]]) -> None:
+        """
+        使用配置更新当前Agent实例的Block层次结构。
+        """
+        # 更新当前Agent的基础参数
+        for field in self.configurable_fields:
+            if field in config["config"]:
+                if config["config"][field] != "default_value":
+                    setattr(self, field, config["config"][field])
+
+        # 递归更新或创建顶层Block
+        for block_data in config.get("blocks", []):
+            block_name = block_data["name"]
+            existing_block = getattr(self, block_name, None)
+
+            if existing_block:
+                # 如果Block已经存在，则递归更新
+                existing_block.load_from_config(block_data)
+            else:
+                raise KeyError(f"Block '{block_name}' not found in agent '{self.__class__.__name__}'")
+
+    def load_from_file(self, filepath: str) -> None:
+        with open(filepath, "r") as f:
+            config = json.load(f)
+            self.load_from_config(config)
+
     def set_messager(self, messager: Messager):  # type:ignore
         """
         Set the messager of the agent.
@@ -218,6 +315,11 @@ class Agent(ABC):
                 f"Copy Writer access before assignment, please `set_pgsql_writer` first!"
             )
         return self._pgsql_writer
+    
+    async def messager_ping(self):
+        if self._messager is None:
+            raise RuntimeError("Messager is not set")
+        return await self._messager.ping()
 
     async def generate_user_survey_response(self, survey: dict) -> str:
         """生成回答 —— 可重写
@@ -527,6 +629,8 @@ class Agent(ABC):
         统一的Agent执行入口
         当_blocked为True时，不执行forward方法
         """
+        if self._messager is not None:
+            await self._messager.ping.remote()
         if not self._blocked:
             await self.forward()
 
@@ -621,10 +725,11 @@ class CitizenAgent(Agent):
                 except:
                     pass
                 person_id = await self.memory.get("id")
+                currency = await self.memory.get("currency")
                 await self._economy_client.add_agents(
                     {
                         "id": person_id,
-                        "currency": await self.memory.get("currency"),
+                        "currency": currency,
                     }
                 )
                 self._has_bound_to_economy = True

pycityagent/cityagent/__init__.py

@@ -0,0 +1,20 @@
+from .societyagent import SocietyAgent
+from .firmagent import FirmAgent
+from .bankagent import BankAgent
+from .nbsagent import NBSAgent
+from .governmentagent import GovernmentAgent
+from .memory_config import memory_config_societyagent, memory_config_government, memory_config_firm, memory_config_bank, memory_config_nbs
+
+__all__ = [
+    "SocietyAgent",
+    "FirmAgent",
+    "BankAgent",
+    "NBSAgent",
+    "GovernmentAgent",
+    "memory_config_societyagent",
+    "memory_config_government",
+    "memory_config_firm",
+    "memory_config_bank",
+    "memory_config_nbs",
+]
+

pycityagent/cityagent/bankagent.py

@@ -0,0 +1,54 @@
+import asyncio
+from typing import Optional
+
+import numpy as np
+from pycityagent import Simulator, InstitutionAgent
+from pycityagent.llm.llm import LLM
+from pycityagent.economy import EconomyClient
+from pycityagent.message import Messager
+from pycityagent.memory import Memory
+import logging
+
+logger = logging.getLogger("pycityagent")
+
+class BankAgent(InstitutionAgent):    
+    def __init__(self, 
+                 name: str,
+                 llm_client: Optional[LLM] = None,
+                 simulator: Optional[Simulator] = None,
+                 memory: Optional[Memory] = None,
+                 economy_client: Optional[EconomyClient] = None,
+                 messager: Optional[Messager] = None,
+                 avro_file: Optional[dict] = None,
+                 ) -> None:
+        super().__init__(name=name, llm_client=llm_client, simulator=simulator, memory=memory, economy_client=economy_client, messager=messager, avro_file=avro_file)
+        self.initailzed = False
+        self.last_time_trigger = None
+        self.time_diff = 30 * 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:
+            self.last_time_trigger = now_time
+            return False
+        if now_time - self.last_time_trigger >= self.time_diff:
+            self.last_time_trigger = now_time
+            return True
+        return False
+    
+    async def gather_messages(self, agent_ids, content):
+        infos = await super().gather_messages(agent_ids, content)
+        return [info['content'] for info in infos]
+
+    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)
+            self.forward_times += 1
+            for uuid in citizens:
+                await self.send_message_to_agent(uuid, f"bank_forward@{self.forward_times}")

pycityagent/cityagent/blocks/__init__.py

@@ -0,0 +1,20 @@
+from .mobility_block import MobilityBlock
+from .cognition_block import CognitionBlock
+from .plan_block import PlanBlock
+from .needs_block import NeedsBlock
+from .social_block import SocialBlock
+from .economy_block import EconomyBlock
+from .other_block import OtherBlock
+from .time_block import TimeBlock
+
+__all__ = [
+    "MobilityBlock",
+    "CognitionBlock",
+    "PlanBlock",
+    "NeedsBlock",
+    "SocialBlock",
+    "EconomyBlock",
+    "OtherBlock",
+    "LongTermDecisionBlock",    
+    "TimeBlock",
+]

pycityagent/cityagent/blocks/cognition_block.py

@@ -0,0 +1,304 @@
+from pycityagent.llm.llm import LLM
+from pycityagent.workflow.block import Block
+from pycityagent.memory import Memory
+from pycityagent.environment.simulator import Simulator
+from pycityagent.workflow.prompt import FormatPrompt
+import json
+import logging
+logger = logging.getLogger("pycityagent")
+
+def extract_json(output_str):
+    try:
+        # Find the positions of the first '{' and the last '}'
+        start = output_str.find('{')
+        end = output_str.rfind('}')
+        
+        # Extract the substring containing the JSON
+        json_str = output_str[start:end+1]
+        
+        # Convert the JSON string to a dictionary
+        return json_str
+    except (ValueError, json.JSONDecodeError) as e:
+        logger.warning(f"Failed to extract JSON: {e}")
+        return None
+
+class CognitionBlock(Block):
+    def __init__(self, llm: LLM, memory: Memory, simulator: Simulator):
+        super().__init__("CognitionBlock", llm, memory, simulator)
+        self.last_trigger_time = None
+        self.time_diff = 24*60*60 # 24小时
+        self.trigger_time = 0
+        self.token_consumption = 0
+        
+    async def set_status(self, status):
+        for key in status:
+            await self.memory.update(key, status[key])
+        return
+    
+    async def check_trigger(self):
+        now_time = await self.simulator.get_time()
+        if self.last_trigger_time is None or now_time - self.last_trigger_time > self.time_diff:
+            self.last_trigger_time = now_time
+            return True
+        return False
+    
+    async def attitude_update(self, topic):
+        description_prompt = """
+        You are a {gender}, aged {age}, belonging to the {race} race and identifying as {religion}. 
+        Your marital status is {marital_status}, and you currently reside in a {residence} area. 
+        Your occupation is {occupation}, and your education level is {education}. 
+        You are {personality}, with a consumption level of {consumption} and a family consumption level of {family_consumption}. 
+        Your income is {income}, and you are skilled in {skill}.
+        My current emotion intensities are (0 meaning not at all, 10 meaning very much):
+        sadness: {sadness}, joy: {joy}, fear: {fear}, disgust: {disgust}, anger: {anger}, surprise: {surprise}.
+        You have the following thoughts: {thought}.
+        In the following 21 words, I have chosen {emotion_types} to represent your current status:
+        Joy, Distress, Resentment, Pity, Hope, Fear, Satisfaction, Relief, Disappointment, Pride, Admiration, Shame, Reproach, Liking, Disliking, Gratitude, Anger, Gratification, Remorse, Love, Hate.
+        """
+        incident_list = await self.memory.get("incident")
+        if incident_list:
+            incident_prompt = "Today, these incidents happened:"
+            for incident in incident_list:
+                incident_prompt += incident
+        else:
+            incident_prompt = "No incidents happened today."
+        attitude = await self.memory.get("attitude")
+        if topic in attitude:
+            previous_attitude = str(attitude[topic])  # Convert to string
+            problem_prompt = (
+                f"You need to decide your attitude towards topic: {topic}, "
+                f"which you previously rated your attitude towards this topic as: {previous_attitude} "
+                "(0 meaning oppose, 10 meaning support). "
+                "Please return a new attitude rating (0-10, smaller meaning oppose, larger meaning support) in JSON format, and explain, e.g. {{\"attitude\": 5}}"
+            )
+        else:
+            problem_prompt = (
+                f"You need to decide your attitude towards topic: {topic}, "
+                "which you have not rated your attitude towards this topic yet. "
+                "(0 meaning oppose, 10 meaning support). "
+                "Please return a new attitude rating (0-10, smaller meaning oppose, larger meaning support) in JSON format, and explain, e.g. {{\"attitude\": 5}}"
+            )
+        question_prompt = description_prompt + incident_prompt + problem_prompt
+        question_prompt = FormatPrompt(question_prompt)
+        emotion = await self.memory.get("emotion")
+        sadness = emotion["sadness"]
+        joy = emotion["joy"]
+        fear = emotion["fear"]
+        disgust = emotion["disgust"]
+        anger = emotion["anger"]
+        surprise = emotion["surprise"]
+        
+        question_prompt.format(
+            gender=await self.memory.get("gender"),
+            age=await self.memory.get("age"),
+            race=await self.memory.get("race"),
+            religion=await self.memory.get("religion"),
+            marital_status=await self.memory.get("marital_status"),
+            residence=await self.memory.get("residence"),
+            occupation=await self.memory.get("occupation"),
+            education=await self.memory.get("education"),
+            personality=await self.memory.get("personality"),
+            consumption=await self.memory.get("consumption"),
+            family_consumption=await self.memory.get("family_consumption"),
+            income=await self.memory.get("income"),
+            skill=await self.memory.get("skill"),
+            sadness=sadness,
+            joy=joy,
+            fear=fear,
+            disgust=disgust,
+            anger=anger,
+            surprise=surprise,
+            thought=await self.memory.get("thought"),
+            emotion_types=await self.memory.get("emotion_types")
+        )
+        evaluation = True
+        for retry in range(10):
+            try:
+                response = await self.llm.atext_request(question_prompt.to_dialog(), timeout=300)
+                response = json.loads(extract_json(response))
+                evaluation = False
+                break
+            except:
+                pass
+        if evaluation:
+            raise f"Request for attitude:{topic} update failed"
+        logger.info(f"""Cognition updated attitude:{topic}:
+            attitude: {response['attitude']}""")
+        attitude[topic] = response["attitude"]
+        await self.memory.update("attitude", attitude)
+        return
+    
+    async def forward(self): #每日结算
+        whether_trigger = await self.check_trigger()
+        if not whether_trigger:
+            return
+        self.trigger_time += 1
+        consumption_start = self.llm.prompt_tokens_used + self.llm.completion_tokens_used
+
+        description_prompt = """
+        You are a {gender}, aged {age}, belonging to the {race} race and identifying as {religion}. 
+        Your marital status is {marital_status}, and you currently reside in a {residence} area. 
+        Your occupation is {occupation}, and your education level is {education}. 
+        You are {personality}, with a consumption level of {consumption} and a family consumption level of {family_consumption}. 
+        Your income is {income}, and you are skilled in {skill}.
+        My current emotion intensities are (0 meaning not at all, 10 meaning very much):
+        sadness: {sadness}, joy: {joy}, fear: {fear}, disgust: {disgust}, anger: {anger}, surprise: {surprise}.
+        You have the following thoughts: {thought}.
+        In the following 21 words, I have chosen {emotion_types} to represent your current status:
+        Joy, Distress, Resentment, Pity, Hope, Fear, Satisfaction, Relief, Disappointment, Pride, Admiration, Shame, Reproach, Liking, Disliking, Gratitude, Anger, Gratification, Remorse, Love, Hate.
+        """
+        incident_list = await self.memory.get("incident")
+        if incident_list:
+            incident_prompt = "Today, these incidents happened:"
+            for incident in incident_list:
+                incident_prompt += incident
+        else:
+            incident_prompt = "No incidents happened today."
+        question_prompt = """
+            Please reconsider your emotion intensities: 
+            sadness, joy, fear, disgust, anger, surprise (0 meaning not at all, 10 meaning very much).
+            Also summerize you current thoughts, and choose a word to describe your status: Joy, Distress, Resentment, Pity, Hope, Fear, Satisfaction, Relief, Disappointment, Pride, Admiration, Shame, Reproach, Liking, Disliking, Gratitude, Anger, Gratification, Remorse, Love, Hate.
+            Return in JSON format, e.g. {{"sadness": 5, "joy": 5, "fear": 5, "disgust": 5, "anger": 5, "surprise": 5, "thought": "Currently nothing good or bad is happening, I think ....", "word": "Relief"}}"""
+        question_prompt = description_prompt + incident_prompt + question_prompt
+        question_prompt = FormatPrompt(question_prompt)
+        emotion = await self.memory.get("emotion")
+        sadness = emotion["sadness"]
+        joy = emotion["joy"]
+        fear = emotion["fear"]
+        disgust = emotion["disgust"]
+        anger = emotion["anger"]
+        surprise = emotion["surprise"]
+        question_prompt.format(
+            gender=await self.memory.get("gender"),
+            age=await self.memory.get("age"),
+            race=await self.memory.get("race"),
+            religion=await self.memory.get("religion"),
+            marital_status=await self.memory.get("marital_status"),
+            residence=await self.memory.get("residence"),
+            occupation=await self.memory.get("occupation"),
+            education=await self.memory.get("education"),
+            personality=await self.memory.get("personality"),
+            consumption=await self.memory.get("consumption"),
+            family_consumption=await self.memory.get("family_consumption"),
+            income=await self.memory.get("income"),
+            skill=await self.memory.get("skill"),
+            sadness=sadness,
+            joy=joy,
+            fear=fear,
+            disgust=disgust,
+            anger=anger,
+            surprise=surprise,
+            emotion=await self.memory.get("emotion"),
+            thought=await self.memory.get("thought"),
+            emotion_types=await self.memory.get("emotion_types")
+        )
+        
+        evaluation = True
+        for retry in range(10):
+            try:
+                response = await self.llm.atext_request(question_prompt.to_dialog(), timeout=300)
+                response = json.loads(extract_json(response))
+                evaluation = False
+                break
+            except:
+                pass
+        if evaluation:
+            raise Exception("Request for cognition update failed")
+        logger.info(f"""Cognition updated emotion intensities:
+            sadness: {response['sadness']},
+            joy: {response['joy']},
+            fear: {response['fear']},
+            disgust: {response['disgust']},
+            anger: {response['anger']},
+            surprise: {response['surprise']}"
+            thought: {response['thought']}
+            emotion_types: {response['word']}""")
+        
+        await self.memory.update("incident", [])
+        await self.memory.update("emotion", {"sadness": int(response["sadness"]), "joy": int(response["joy"]), "fear": int(response["fear"]), "disgust": int(response["disgust"]), "anger": int(response["anger"]), "surprise": int(response["surprise"])})
+        await self.memory.update("thought", str(response["thought"]))
+        await self.memory.update("emotion_types", str(response["word"]))
+
+        consumption_end = self.llm.prompt_tokens_used + self.llm.completion_tokens_used
+        self.token_consumption += consumption_end - consumption_start
+        return
+    
+    async def emotion_update(self, incident): #每日结算
+        whether_trigger = await self.check_trigger()
+        if not whether_trigger:
+            return
+
+        description_prompt = """
+        You are a {gender}, aged {age}, belonging to the {race} race and identifying as {religion}. 
+        Your marital status is {marital_status}, and you currently reside in a {residence} area. 
+        Your occupation is {occupation}, and your education level is {education}. 
+        You are {personality}, with a consumption level of {consumption} and a family consumption level of {family_consumption}. 
+        Your income is {income}, and you are skilled in {skill}.
+        My current emotion intensities are (0 meaning not at all, 10 meaning very much):
+        sadness: {sadness}, joy: {joy}, fear: {fear}, disgust: {disgust}, anger: {anger}, surprise: {surprise}.
+        You have the following thoughts: {thought}.
+        In the following 21 words, I have chosen {emotion_types} to represent your current status:
+        Joy, Distress, Resentment, Pity, Hope, Fear, Satisfaction, Relief, Disappointment, Pride, Admiration, Shame, Reproach, Liking, Disliking, Gratitude, Anger, Gratification, Remorse, Love, Hate.
+        """
+
+        incident_prompt = incident  #waiting for incident port
+        question_prompt = """
+            Please reconsider your emotion intensities: 
+            sadness, joy, fear, disgust, anger, surprise (0 meaning not at all, 10 meaning very much).
+            Return in JSON format, e.g. {{"sadness": 5, "joy": 5, "fear": 5, "disgust": 5, "anger": 5, "surprise": 5}}"""
+        question_prompt = description_prompt + incident_prompt + question_prompt
+        question_prompt = FormatPrompt(question_prompt)
+        emotion = await self.memory.get("emotion")
+        sadness = emotion["sadness"]
+        joy = emotion["joy"]
+        fear = emotion["fear"]
+        disgust = emotion["disgust"]
+        anger = emotion["anger"]
+        surprise = emotion["surprise"]
+        question_prompt.format(
+            gender=await self.memory.get("gender"),
+            age=await self.memory.get("age"),
+            race=await self.memory.get("race"),
+            religion=await self.memory.get("religion"),
+            marital_status=await self.memory.get("marital_status"),
+            residence=await self.memory.get("residence"),
+            occupation=await self.memory.get("occupation"),
+            education=await self.memory.get("education"),
+            personality=await self.memory.get("personality"),
+            consumption=await self.memory.get("consumption"),
+            family_consumption=await self.memory.get("family_consumption"),
+            income=await self.memory.get("income"),
+            skill=await self.memory.get("skill"),
+            sadness=sadness,
+            joy=joy,
+            fear=fear,
+            disgust=disgust,
+            anger=anger,
+            surprise=surprise,
+            emotion=await self.memory.get("emotion"),
+            thought=await self.memory.get("thought"),
+            emotion_types=await self.memory.get("emotion_types")
+        )
+        
+        evaluation = True
+        for retry in range(10):
+            try:
+                response = await self.llm.atext_request(question_prompt.to_dialog(), timeout=300)
+                response = json.loads(extract_json(response))
+                evaluation = False
+                break
+            except Exception as e:
+                print(e)
+                pass
+        if evaluation:
+            raise Exception("Request for cognition update failed")
+        logger.info(f"""Cognition updated emotion intensities:
+            sadness: {response['sadness']},
+            joy: {response['joy']},
+            fear: {response['fear']},
+            disgust: {response['disgust']},
+            anger: {response['anger']},
+            surprise: {response['surprise']}""")
+
+        await self.memory.update("emotion", {"sadness": int(response["sadness"]), "joy": int(response["joy"]), "fear": int(response["fear"]), "disgust": int(response["disgust"]), "anger": int(response["anger"]), "surprise": int(response["surprise"])})
+        return

pycityagent/cityagent/blocks/dispatcher.py

@@ -0,0 +1,78 @@
+import random
+from typing import Dict, List
+from pycityagent.llm.llm import LLM
+from pycityagent.workflow.block import Block
+from pycityagent.workflow.prompt import FormatPrompt
+import logging
+logger = logging.getLogger("pycityagent")
+
+DISPATCHER_PROMPT = """
+Based on the step information, select the most appropriate block to handle the task.
+Each block has its specific functionality as described in the function schema.
+        
+Step information:
+{step}
+"""
+
+class BlockDispatcher:
+    def __init__(self, llm: LLM):
+        self.llm = llm
+        self.blocks: Dict[str, Block] = {}
+        self.prompt = FormatPrompt(DISPATCHER_PROMPT)
+        
+    def register_blocks(self, blocks: List[Block]) -> None:
+        """Register multiple blocks at once"""
+        for block in blocks:
+            block_name = block.__class__.__name__.lower()
+            self.blocks[block_name] = block
+        
+    def _get_function_schema(self) -> dict:
+        """Generate function schema for LLM function call"""
+        # 创建 block 选项说明
+        block_descriptions = {
+            name: block.description  # type: ignore
+            for name, block in self.blocks.items()
+        }
+        
+        return {
+            "type": "function",
+            "function": {
+                "name": "select_block",
+                "description": "Select the most appropriate block based on the step information",
+                "parameters": {
+                    "type": "object",
+                    "properties": {
+                        "block_name": {
+                            "type": "string",
+                            "enum": list(self.blocks.keys()),
+                            "description": f"Available blocks and their descriptions: {block_descriptions}"
+                        }
+                    },
+                    "required": ["block_name"]
+                }
+            }
+        }
+        
+    async def dispatch(self, step: dict) -> Block:
+        """Dispatch the step to appropriate block based on LLM function call"""
+        try:
+            function_schema = self._get_function_schema()
+            self.prompt.format(step=step)
+            
+            # Call LLM with tools schema
+            function_args = await self.llm.atext_request(
+                self.prompt.to_dialog(),
+                tools=[function_schema],
+                tool_choice={"type": "function", "function": {"name": "select_block"}}
+            )
+                    
+            selected_block = function_args.get("block_name") # type: ignore
+            
+            if selected_block not in self.blocks:
+                raise ValueError(f"Selected block '{selected_block}' not found in registered blocks")
+                
+            return self.blocks[selected_block]
+            
+        except Exception as e:
+            logger.warning(f"Failed to dispatch block: {e}")
+            return random.choice(list(self.blocks.values()))