Rework RolePlaying API

[Obs01ete]

Now we have two API calls:

def init_chat(self) -> Tuple[BaseMessage, List[BaseMessage]]

and

def step(
        self,
        assistant_msg: BaseMessage,
    ) -> Tuple[ChatAgentResponse, ChatAgentResponse]

Init is always called like this:

input_assistant_msg, _ = role_play_session.init_chat()

So we can remove the second output, since it is never used.

Also troublesome that step has a message as an input.

My proposed API will be like this:

def reset() -> None
"""Only resets agents and the internal state machine. Does not make agent steps."""

def step() -> None
"""Gets the saved message from the previous spoken agent and feeds into the current agent.
Saves the answer internally by overwriting the `_saved_message`.
If it is the first or the second step, feeds the intro messages into the agents."""

def get_response() -> ChatAgentResponse
"""Gets the internally saved answer of the latest spoken agent.
If queried multiple times between steps, returns the same message"""

def is_external_critic_response_required()
"""Effectively checks if the ChatAgentResponse returned by get_response() has multiple options.
This means that the external critic is required to choose between them and submit the choice with submit_message()"""

def submit_message(message: BaseMessage) -> None
"""Overwrites the internally saved `_saved_message` with the provided message.
It may be the edited response, or the critic choice.
Very convenient that a user may skip this call to make the chat go without intervention.
"""

This should support all possible modes like the following.

Chatting without external critic.

session = RolePlaying()
session.reset()
for _ in range(10):
    session.step()
    response = session.get_response()
    print(response.msg)

Notice that no need to feed anything to the step, which used to be troublesome.

Chatting with external critic.

session = RolePlaying(external_critic=True)
session.reset()
for _ in range(10):
    session.step()
    if session.is_external_critic_response_required():
        response_with_options = session.get_response()
        print("Options: ", response_with_options.msgs)
        message = critic.reduce_step(response_with_options.msgs)
        session.submit_message(message)
        print("Choice", message)
    else:
        # so flexible that some steps can query for a critic, some may not: all supported
        response = session.get_response()
        print(response.msg)

Chatting with external editor.

session = RolePlaying()
for _ in range(10):
    session.step()
    response = session.get_response()
    response_edited = response.msg + " Also camels are cute."
    print(response_edited)
    session.submit_message(response_edited)

Related issues #119 #152 #118

@lightaime @oserikov What do you think?

[zechengz]

I agree with your proposed reset and step.

For get_response we may provide something like session.get_response(index=...) (index name here is just for demo purpose, we can use other name at this place) where index indicates the index of chat response. For example get_response(index=0) returns the first response (made by first agent) and get_response(index=1) returns the second response (made by another agent). We can have some default value for index such as -1 that it will return latest response by default.

To me is_external_critic_response_required seems to be a relative special use case, where when there is an external critic agent. Maybe we can make it as a property and make the name shorter.

For submit_message do we only allow user to use it when there is an external critic? Also, will the submitted message be appended to the _saved_message or should we allow user to insert the message to anywhere in the _saved_message the user wants to? WDYT?

[Obs01ete]

@zechengz

For submit_message do we only allow user to use it when there is an external critic?

Not only. Also we can make free edits, see "Chatting with external editor." that I've added.

Also, will the submitted message be appended to the _saved_message

_saved_message is a single message - the most recent response. So no appendings.