class Role:
    """Role/Agent"""
    def __init__(self, name="", profile="", goal="", constraints="", desc=""):
        self._llm = LLM() #llm
        self._setting = RoleSetting(name=name, profile=profile, goal=goal, constraints=constraints, desc=desc)
        self._states = []
        self._actions = [] # ¶ÔÓ¦µÄaction/ stage
        self._role_id = str(self._setting) 
        self._rc = RoleContext()      self._llm = LLM() #llm        self._setting = RoleSetting(name=name, profile=profile, goal=goal, constraints=constraints, desc=desc)        self._states = []        self._actions = [] # ¶ÔÓ¦µÄaction/ stage        self._role_id = str(self._setting)         self._rc = RoleContext()

class RoleSetting(BaseModel):
    """Role Settings"""
    name: str
    profile: str
    goal: str
    constraints: str
    desc: str
class RoleContext(BaseModel):
    """Role Runtime Context"""
    # ά»¤ÔËÐйý³ÌÖеÄһЩ״̬ÐÅÏ¢
    env: 'Environment' = Field(default=None) # environment£¬ËùÓнÇÉ«¹²Ïí
    memory: Memory = Field(default_factory=Memory) # ¼ÇÒäÐÅÏ¢
    state: int = Field(default=0) # ÏÂһʱ¿ÌÒªÖ´ÐеĶ¯×÷
    todo: Action = Field(default=None)
    watch: set[Type[Action]] = Field(default_factory=set) # ¹Ø×¢/¶©ÔĵÄÐÅÏ¢
    news: list[Type[Message]] = Field(default=[]) # ±¾ÂÖÐÂÔöµÄÐÅÏ¢

async def run(self, k=1):
    """´¦ÀíÒ»´ÎËùÓÐÐÅÏ¢µÄÔËÐÐ
    Process all Role runs at once
    """
    for _ in range(k):
        futures = []
        # Ö´ÐÐ
        for role in self.roles.values():
            future = role.run()
            futures.append(future)
        await asyncio.gather(*futures)

async def run(self, message=None):
    """Observe, and think and act based on the results of the observation"""
    if message:
        ...
    # ¹Û²ì»·¾³¡¢¸üÐÂmemory
    elif not await self._observe():
        # If there is no new information, suspend and wait
        return
    # Ö´Ðж¯×÷
    rsp = await self._react()
    # °Ñ½á¹û´«¸øenvironment
    self._publish_message(rsp)
    return rsp

@EnvironmentRegistry.register("basic")
class BasicEnvironment(BaseEnvironment):
    """
    A basic environment implementing the logic of conversation.
    Args:
        agents: List of agents
        rule: Rule for the environment
        max_turns: Maximum number of turns
        cnt_turn: Current turn number
        last_messages: Messages from last turn
        rule_params: Variables set by the rule
    """
    agents: List[BaseAgent]
    rule: Rule
    max_turns: int = 10
    cnt_turn: int = 0
    last_messages: List[Message] = []
    rule_params: Dict = {}
    def __init__(self, rule, **kwargs):
        rule_config = rule
        order_config = rule_config.get("order", {"type": "sequential"})
        visibility_config = rule_config.get("visibility", {"type": "all"})
        selector_config = rule_config.get("selector", {"type": "basic"})
        updater_config = rule_config.get("updater", {"type": "basic"})
        describer_config = rule_config.get("describer", {"type": "basic"})
        rule = Rule(
            order_config,
            visibility_config,
            selector_config,
            updater_config,
            describer_config,
        )
        super().__init__(rule=rule, **kwargs)

class BaseAgent(BaseModel):
    name: str # Ãû×Ö
    llm: BaseLLM # llm
    output_parser: OutputParser # Êä³ö½âÎö
    prompt_template: str # Ä£°å
    role_description: str = Field(default="") # ½ÇÉ«ÐÅÏ¢
    memory: BaseMemory = Field(default_factory=ChatHistoryMemory) # ¼ÇÒä
    max_retry: int = Field(default=3)
    receiver: Set[str] = Field(default=set({"all"})) # ÐÅÏ¢µÄ½ÓÊÕ·½
    async_mode: bool = Field(default=True)

class AgentVerse:
    def __init__(self, agents: List[BaseAgent], environment: BaseEnvironment):
        self.agents = agents
        self.environment = environment
  def run(self):
        """Run the environment from scratch until it is done."""
        self.environment.reset()
        # Ñ­»·Ö´ÐÐ
        while not self.environment.is_done():
            asyncio.run(self.environment.step())

async def step(self) -> List[Message]:
    """Run one step of the environment"""
    # Ñ¡ÔñÏÂһʱ¿ÌµÄÐж¯µÄagent(s)
    agent_ids = self.rule.get_next_agent_idx(self)
    # »·¾³ÃèÊöÐÅÏ¢£¨Ã¿¸öagents²»Ò»¶¨Ò»Ñù£©
    env_descriptions = self.rule.get_env_description(self)
    # agentÐж¯£¬·µ»Ø½á¹û
    messages = await asyncio.gather(
        *[self.agents[i].astep(env_descriptions[i]) for i in agent_ids]
    )
    # Ñ¡Ôñ¹ýÂËmessageÐÅÏ¢
    selected_messages = self.rule.select_message(self, messages)
    # ¸üÐÂmmory
    self.rule.update_memory(self)
    # ¸üÐÂagentÖ®¼äµÄ¿É¼ûÐÔ
    self.rule.update_visible_agents(self)
    self.cnt_turn += 1
    return selected_messages

def step(self, env_description: str = "") -> Message:
    parsed_response = None
    tool_observation = [self.tool_memory.to_string()]
    while True:
        # Æ´½Óprompt
        prompt = self._fill_prompt_template(env_description, tool_observation)
        try:
            # µ÷ÓÃLLM
            response = self.llm.generate_response(prompt)
            # ½âÎö½á¹û
            parsed_response = self.output_parser.parse(response)
            if isinstance(parsed_response, AgentAction):
                # µ÷Óù¤¾ß
                observation = self._call_tool(parsed_response)
                tool_observation.append(
                    parsed_response.log.strip()
                    + f"\nObservation: {observation.strip()}"
                )
            break
        except BaseException as e:
            logging.error(e)
            logging.warning("Retrying...")
            continue
        if parsed_response is None or isinstance(parsed_response, AgentFinish):
            break
    self._update_tool_memory(tool_observation)
    message = Message(
        content=""
        if parsed_response is None
        else parsed_response.return_values["output"],
        sender=self.name,
        receiver=self.get_receiver(),
    )
    return message

def run(agents,sop,environment):
    while True:
        # ¸üÐÂ״̬£¬¾ö¶¨ÏÂÒ»¸öÐж¯µÄagent
        current_state,current_agent= sop.next(environment,agents)
        if sop.finished:
            os.environ.clear()
            break
      # agentÖ´ÐÐ
        action = current_agent.step(current_state)
        # ¸üÐÂmemory
        memory = process(action)
        environment.update_memory(memory,current_state)

def next(self, environment, agents):
    """
    Determine the next state and the agent that needs action based on the current situation
    """
  # һЩ³õʼ»¯Á÷³Ì£º»ñÈ¡¼ÇÒä¡¢Ïà¹ØÐÅÏ¢µÈ
  ...
    # ÏÂһʱ¿ÌµÄ״̬
    next_state = self.transit(
        chat_history=environment.shared_memory["long_term_memory"][
            environment.current_chat_history_idx :
        ],
        relevant_history=relevant_history,
        environment=environment,
    )
    # Èç¹û½øÈëÖÕÖ¹½Úµã£¬ÔòÖ±½ÓÖÕÖ¹
    if next_state.name == self.finish_state_name:
        self.finished = True
        return None, None
  # ¸üÐÂ״̬
    self.current_state = next_state
  # ¾ö¶¨ÏÂһʱ¿ÌÒªÐж¯µÄagent
    next_agent = self.route(
        chat_history=environment.shared_memory["long_term_memory"][
            environment.current_chat_history_idx :
        ],
        agents = agents,
        relevant_history=relevant_history,
    )
    return self.current_state, next_agent

def step(self, current_state,input=""):
    """
    return actions by current state and environment
    Return: action(Action)
    """
    current_state.chat_nums +=1
    state_begin = current_state.is_begin
    agent_begin = self.begins[current_state.name]["is_begin"]
    self.begins[current_state.name]["is_begin"] = False
    current_state.is_begin = False
    environment = self.environment
    self.current_state = current_state
    # Ïȸù¾Ýµ±Ç°»·¾³¸üÐÂÐÅÏ¢    
    if len(environment.shared_memory["long_term_memory"])>0:
        current_history = self.observe()
        self.long_term_memory.append(current_history)
    response,res_dict = self.act()
    action_dict =  {
        "response": response,
        "res_dict": res_dict,
        "role": self.state_roles[current_state.name],
        "name": self.name,
        "state_begin" : state_begin,
        "agent_begin" : agent_begin,
        "is_user" : self.is_user
    }
    return  Action(**action_dict)
def act(self):
    """
    return actions by the current state
    """
    current_state = self.current_state
    chat_history = self.long_term_memory
    current_LLM = self.LLMs[current_state.name]
    # Æ´½Óprompt
    system_prompt, last_prompt, res_dict = self.compile()
    # µ÷ÓÃLLM
    response = current_LLM.get_response(
        chat_history, system_prompt, last_prompt, stream=True
    )
    return response,res_dict

class Memory:
    def __init__(self,role,name,content) -> None:
        self.send_role = role
        self.send_name = name
        self.content = content
def update_memory(self, memory, current_state):
    """
    ¸üл·¾³µÄmemoryÐÅÏ¢
    """
    MAX_CHAT_HISTORY = eval(os.environ["MAX_CHAT_HISTORY"])
    self.shared_memory["long_term_memory"].append(memory)
    current_embedding = get_embedding(memory.content)
  # ¶Ô¹ýÈ¥¼¸ÂÖÐÅÏ¢×÷summary
    if len(self.shared_memory["long_term_memory"]) % MAX_CHAT_HISTORY == 0:
        summary = self.summary(current_state)
        self.shared_memory["short_term_memory"] = summary
    self.agents[memory.send_name].update_memory(memory)