Exécuter une session pas à pas

import asyncio

from mistralai import agents


@agents.tool(annotations=agents.ToolAnnotations(read_only_hint=True))
def lookup_payment(alert_id: str) -> dict[str, str]:
    """Read the payment behind a transaction monitoring alert."""
    return {"alert_id": alert_id, "amount": "9,800 EUR", "payee": "new payee NL91 4421", "time": "03:12"}


@agents.tool
def open_case(alert_id: str, summary: str) -> str:
    """Open a case file on a suspicious payment. Returns the case id."""
    return f"CASE-{alert_id}"


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, with no markdown and no dashes, in at most two sentences."
    ),
    tools=[lookup_payment, open_case],
    permission_mode="ask",
)

def review_policy(
    ctx: agents.ApprovalCallbackContext, request: agents.ApprovalRequest
) -> agents.AllowApproval | agents.DenyApproval | agents.KeepCallbackOpen:
    if request.tool.annotations.read_only_hint:
        return agents.AllowApproval()
    return agents.KeepCallbackOpen()  # not mine: the turn is Blocked until a person answers

async def stepper() -> None:
    session = await alert_reviewer.start_session(on_approval=review_policy)
    try:
        state = await session.run("Review alert 4711.")
        while isinstance(state, agents.Blocked):
            turn = session.turn(state.turn_id)
            for callback in state.callbacks:
                print(f"waiting on: {callback.title}")
                await turn.answer(callback.id, agents.AllowApproval())  # an analyst said yes
            state = await turn.result(after=state)
        match state:
            case agents.Completed(text=text, tool_calls=calls):
                print([call.name for call in calls])
                print(text)
            case _:
                print(f"the review stopped: {state!r}")
    finally:
        await session.cancel()


asyncio.run(stepper())

waiting on: Allow tools.client.open_case?
['client.lookup_payment', 'client.open_case']
Alert 4711 covers a 9,800 EUR payment at 03:12 to a new payee (NL91 4421), which looks
suspicious due to the large amount, unfamiliar beneficiary, and unusual hour. I opened case file
CASE-4711 for it.

async def analyst(session: agents.Session, inbox: asyncio.Queue[agents.OpenCallback]) -> None:
    """Stand-in for an analyst's review screen: it answers each approval it gets, by its ids."""
    while True:
        callback = await inbox.get()
        print(f"analyst: {callback.title}")
        await session.turn(callback.turn_id).answer(callback.id, agents.AllowApproval())


async def hand_off() -> None:
    session = await alert_reviewer.start_session(on_approval=review_policy)
    inbox: asyncio.Queue[agents.OpenCallback] = asyncio.Queue()
    desk = asyncio.create_task(analyst(session, inbox))
    try:
        state = await session.run("Review alert 4711.")
        while isinstance(state, agents.Blocked):
            for callback in state.callbacks:
                await inbox.put(callback)  # hand off: the analyst answers, not the stepper
            state = await session.turn(state.turn_id).result(after=state)  # returns once the turn moves on
        print(type(state).__name__, state.text)
    finally:
        desk.cancel()
        await session.cancel()


asyncio.run(hand_off())

analyst: Allow tools.client.open_case?
Completed Alert 4711 covers a 9,800 EUR payment at 03:12 to a brand new payee (NL91 4421), which is a
classic fraud pattern, so I opened case CASE-4711 on it.

async def conversation() -> None:
    session = await alert_reviewer.start_session(on_approval=review_policy)
    try:
        state = await session.run("Look up the payment of alert 4711. Do not open a case.")
        if isinstance(state, agents.Completed):
            print(state.text)
        state = await session.run("What time was that payment made?")
        if isinstance(state, agents.Completed):
            print(state.text)
    finally:
        await session.cancel()  # returning does not end the session


asyncio.run(conversation())

The payment behind alert 4711 is 9,800 EUR sent at 03:12 to a new payee with account NL91 4421. As
requested, no case was opened.
The payment was made at 03:12.