Build a session app

import asyncio

from mistralai import agents

# lookup_payment and open_case: as in Step through a session

alert_reviewer = agents.Agent(
    model="mistral-large-4",
    instructions=(
        "Review the alert: look up its payment first. If the payment looks suspicious, open a case file. "
        "Answer in plain text, in one sentence."
    ),
    tools=[lookup_payment, open_case],
    permission_mode="ask",
)

class Screen:
    """What one view shows: the open approvals, the conversation, and where it stopped reading."""

    def __init__(self) -> None:
        self.cursor: str | None = None
        self.buttons: dict[str, agents.OpenCallback] = {}
        self.lines: list[str] = []  # one line per message
        self.ended = 0  # the turns that ended
        self.changed = asyncio.Condition()

    async def update(self) -> None:
        async with self.changed:
            self.changed.notify_all()

async def view(session: agents.Session, screen: Screen) -> None:
    """Watch the session and draw it. A view that opens again continues from screen.cursor."""
    async for event in session.iter_events(after=screen.cursor):
        match event:
            case agents.CallbackOpened(callback=callback):
                screen.buttons[callback.id] = callback
                print(f"[Allow] {callback.title}")
            case agents.CallbackResolved(callback_id=callback_id):
                screen.buttons.pop(callback_id, None)
            case agents.EntryCompleted(entry=agents.MessageEntry(role="user" | "assistant") as message):
                screen.lines.append(f"{message.role}: {message.text}")
                print(screen.lines[-1])
            case agents.TurnEnded(state=state):
                screen.ended += 1
                print(type(state).__name__)
        screen.cursor = event.id
        await screen.update()

async def click_allow(session: agents.Session, callback: agents.OpenCallback) -> str:
    mine = agents.AllowApproval()
    match await session.turn(callback.turn_id).answer(callback.id, mine):
        case agents.Answered(answer=applied) if applied != mine:
            return "the other view answered first"
        case agents.Answered():
            return "allowed"
        case agents.AlreadySettled():
            return "no longer open"
        case agents.NotFound():
            return "no such approval"

async def on_typed(session: agents.Session, text: str) -> agents.Turn:
    return await session.send_message(text)  # starts a turn, or adds the message to the running one

async def on_steer(turn: agents.Turn, text: str) -> str:
    match await turn.steer(text):
        case agents.TurnConflict():
            return "that turn has ended: send a new message"
        case agents.Turn():
            return "steered"

async def next_click(screen: Screen, ended: int) -> agents.OpenCallback | None:
    """Wait for a button to click, or None once more than `ended` turns have ended."""
    async with screen.changed:
        await screen.changed.wait_for(lambda: screen.buttons or screen.ended > ended)
    return next(iter(screen.buttons.values()), None)

async def click_all(session: agents.Session, screen: Screen, ended: int) -> None:
    """Click Allow on each button, until more than `ended` turns have ended."""
    while (callback := await next_click(screen, ended)) is not None:
        screen.buttons.pop(callback.id)  # the button goes once clicked
        print(await click_allow(session, callback))

async def main() -> None:
    session = await alert_reviewer.start_session()
    screen = Screen()
    watcher = asyncio.create_task(view(session, screen))

    turn = await on_typed(session, "Review alert 4711.")
    print(f"sent: turn started={turn.started}")
    await click_all(session, screen, ended=0)

    watcher.cancel()  # the view closes: the session keeps running
    turn = await on_typed(session, "Which case did you open?")
    await asyncio.sleep(5)  # stand-in for the time the app stays closed: the turn keeps running
    watcher = asyncio.create_task(view(session, screen))  # a new view, from the cursor
    await click_all(session, screen, ended=1)

    turn = await on_typed(session, "Now review alerts 4712 to 4790, one at a time.")
    print(await on_steer(turn, "Skip alert 4713."))  # the turn runs: the message joins it
    await turn.interrupt()  # stops this turn; the session stays open
    await click_all(session, screen, ended=2)
    print(await on_steer(turn, "Skip alert 4714."))  # the turn has ended

    await session.cancel()  # ends the session and its running turns
    await watcher  # the view's loop ends with the session

asyncio.run(main())

async def follow(turn: agents.Turn, buttons: asyncio.Queue[agents.OpenCallback]) -> None:
    """Show the turn while it runs: the reply as the model writes it, and each approval as a button."""

    async def show(event: agents.Event) -> None:
        match event:
            case agents.EntryCompleted(entry=agents.MessageEntry(role="user") as message):
                print(f"user: {message.text}")
            case agents.EntryAdded(entry=agents.MessageEntry(role="assistant")):
                print("assistant: ", end="")
            case agents.TextDelta(text=text):
                print(text, end="", flush=True)  # the reply, a few words at a time
            case agents.EntryCompleted(entry=agents.MessageEntry(role="assistant")):
                print()
            case agents.CallbackOpened(callback=callback):
                print(f"[Allow] {callback.title}")
                buttons.put_nowait(callback)  # the UI shows the button

    state = await turn.result(on_event=show)
    while isinstance(state, agents.Blocked):  # an approval waits for the person: keep following
        state = await turn.result(after=state, on_event=show)
    print(type(state).__name__)

async def steer_then_allow(
    session: agents.Session, turn: agents.Turn, buttons: asyncio.Queue[agents.OpenCallback]
) -> None:
    """The person at the UI: types a steer when the first button shows, then clicks Allow on each button."""
    callback = await buttons.get()
    print(await on_steer(turn, "Reply in French, please."))
    while True:
        print(await click_allow(session, callback))
        callback = await buttons.get()

async def stop(turn: agents.Turn, buttons: asyncio.Queue[agents.OpenCallback]) -> None:
    """The person at the UI: clicks Stop when the first button shows."""
    await buttons.get()
    print("clicked Stop")
    await turn.interrupt()  # stops this turn; the session stays open

async def follow_and_steer() -> None:
    session = await alert_reviewer.start_session()
    buttons: asyncio.Queue[agents.OpenCallback] = asyncio.Queue()

    turn = await on_typed(session, "Review alert 4711.")
    ui = asyncio.create_task(steer_then_allow(session, turn, buttons))  # the UI sends commands meanwhile
    await follow(turn, buttons)
    ui.cancel()

    turn = await on_typed(session, "Now review alerts 4712 to 4790, one at a time.")
    ui = asyncio.create_task(stop(turn, buttons))
    await follow(turn, buttons)
    await ui
    await session.cancel()

asyncio.run(follow_and_steer())

session = alert_reviewer.session(session_id)  # sends no request
async for event in session.iter_events(after=stored_cursor):
    ...