Agentenzustand

Die Klasse State ist eine grundlegende Komponente des UFO-Agenten-Frameworks. Sie repräsentiert den aktuellen Zustand des Agenten und bestimmt die nächste Aktion und den nächsten Agenten zur Bearbeitung der Anfrage. Jeder Agent hat eine spezifische Menge von Zuständen, die das Verhalten und den Arbeitsablauf des Agenten definieren.

AgentStatus

Die Menge der Zustände für einen Agenten wird in der Klasse AgentStatus definiert.

class AgentStatus(Enum):
    """
    The status class for the agent.
    """

    ERROR = "ERROR"
    FINISH = "FINISH"
    CONTINUE = "CONTINUE"
    FAIL = "FAIL"
    PENDING = "PENDING"
    CONFIRM = "CONFIRM"
    SCREENSHOT = "SCREENSHOT"

Jeder Agent implementiert seine eigene Menge von AgentStatus, um die Zustände des Agenten zu definieren.

AgentStateManager

Die Klasse AgentStateManager verwaltet die Zuordnung von Zuständen von einem String zur entsprechenden Zustandsklasse. Jede Zustandsklasse wird mit dem Dekorator register beim AgentStateManager registriert, um die Zustandsklasse einem bestimmten Agenten zuzuordnen, z.B.

@AgentStateManager.register
class SomeAgentState(AgentState):
    """
    The state class for the some agent.
    """

Unten sehen Sie die grundlegende Struktur der Klasse AgentStateManager.

class AgentStateManager(ABC, metaclass=SingletonABCMeta):
    """
    A abstract class to manage the states of the agent.
    """

    _state_mapping: Dict[str, Type[AgentState]] = {}

    def __init__(self):
        """
        Initialize the state manager.
        """

        self._state_instance_mapping: Dict[str, AgentState] = {}

    def get_state(self, status: str) -> AgentState:
        """
        Get the state for the status.
        :param status: The status string.
        :return: The state object.
        """

        # Lazy load the state class
        if status not in self._state_instance_mapping:
            state_class = self._state_mapping.get(status)
            if state_class:
                self._state_instance_mapping[status] = state_class()
            else:
                self._state_instance_mapping[status] = self.none_state

        state = self._state_instance_mapping.get(status, self.none_state)

        return state

    def add_state(self, status: str, state: AgentState) -> None:
        """
        Add a new state to the state mapping.
        :param status: The status string.
        :param state: The state object.
        """
        self.state_map[status] = state

    @property
    def state_map(self) -> Dict[str, AgentState]:
        """
        The state mapping of status to state.
        :return: The state mapping.
        """
        return self._state_instance_mapping

    @classmethod
    def register(cls, state_class: Type[AgentState]) -> Type[AgentState]:
        """
        Decorator to register the state class to the state manager.
        :param state_class: The state class to be registered.
        :return: The state class.
        """
        cls._state_mapping[state_class.name()] = state_class
        return state_class

    @property
    @abstractmethod
    def none_state(self) -> AgentState:
        """
        The none state of the state manager.
        """
        pass

AgentState

Jede Zustandsklasse erbt von der Klasse AgentState und muss die Methode handle implementieren, um die Aktion im Zustand zu verarbeiten. Zusätzlich werden die Methoden next_state und next_agent verwendet, um den nächsten Zustand und den nächsten Agenten für den Übergang zu bestimmen. Bitte finden Sie unten die Referenz für die Klasse State in UFO.

165
166
167
168
169
170
171
172

@classmethod
@abstractmethod
def agent_class(cls) -> Type[BasicAgent]:
    """
    The class of the agent.
    :return: The class of the agent.
    """
    pass

122
123
124
125
126
127
128
129

@abstractmethod
def handle(self, agent: BasicAgent, context: Optional["Context"] = None) -> None:
    """
    Handle the agent for the current step.
    :param agent: The agent to handle.
    :param context: The context for the agent and session.
    """
    pass

149
150
151
152
153
154
155

@abstractmethod
def is_round_end(self) -> bool:
    """
    Check if the round ends.
    :return: True if the round ends, False otherwise.
    """
    pass

157
158
159
160
161
162
163

@abstractmethod
def is_subtask_end(self) -> bool:
    """
    Check if the subtask ends.
    :return: True if the subtask ends, False otherwise.
    """
    pass

174
175
176
177
178
179
180
181

@classmethod
@abstractmethod
def name(cls) -> str:
    """
    The class name of the state.
    :return: The class name of the state.
    """
    return ""

131
132
133
134
135
136
137
138

@abstractmethod
def next_agent(self, agent: BasicAgent) -> BasicAgent:
    """
    Get the agent for the next step.
    :param agent: The agent for the current step.
    :return: The agent for the next step.
    """
    return agent

140
141
142
143
144
145
146
147

@abstractmethod
def next_state(self, agent: BasicAgent) -> AgentState:
    """
    Get the state for the next step.
    :param agent: The agent for the current step.
    :return: The state for the next step.
    """
    pass