Method step

langroid/agent/task.py:1206–1301

Synchronous version of `step_async()`. See `step_async()` for details. TODO: Except for the self.response() calls, this fn should be identical to `step_async()`. Consider refactoring to avoid duplication.

(self, turns: int = -1)

            )

    def step(self, turns: int = -1) -> ChatDocument | None:
        """
        Synchronous version of `step_async()`. See `step_async()` for details.
        TODO: Except for the self.response() calls, this fn should be identical to
        `step_async()`. Consider refactoring to avoid duplication.
        """
        self.is_done = False
        parent = self.pending_message
        recipient = (
            ""
            if self.pending_message is None
            else self.pending_message.metadata.recipient
        )
        if not self._valid_recipient(recipient):
            logger.warning(f"Invalid recipient: {recipient}")
            error_doc = ChatDocument(
                content=f"Invalid recipient: {recipient}",
                metadata=ChatDocMetaData(
                    sender=Entity.AGENT,
                    sender_name=Entity.AGENT,
                ),
            )
            self._process_valid_responder_result(Entity.AGENT, parent, error_doc)
            return error_doc

        responders: List[Responder] = self.non_human_responders.copy()

        if (
            Entity.USER in self.responders
            and not self.human_tried
            and not self.agent.has_tool_message_attempt(self.pending_message)
        ):
            # Give human first chance if they haven't been tried in last step,
            # and the msg is not a tool-call attempt;
            # (When `interactive=False`, human is only allowed to respond only if
            #  if explicitly addressed)
            # This ensures human gets a chance to respond,
            #   other than to a LLM tool-call.
            # When there's a tool msg attempt we want the
            #  Agent to be the next responder; this only makes a difference in an
            #  interactive setting: LLM generates tool, then we don't want user to
            #  have to respond, and instead let the agent_response handle the tool.

            responders.insert(0, Entity.USER)

        found_response = False
        # (responder, result) from a responder who explicitly said NO_ANSWER
        no_answer_response: None | Tuple[Responder, ChatDocument] = None
        n_non_responders = 0
        for r in responders:
            self.is_pass_thru = False
            if not self._can_respond(r):
                n_non_responders += 1
                # create dummy msg for logging
                log_doc = ChatDocument(
                    content="[CANNOT RESPOND]",
                    metadata=ChatDocMetaData(
                        sender=r if isinstance(r, Entity) else Entity.USER,