0%

LLM-code testen · oefening

Test de agentlus met gescripte antwoorden

ask doet één aanroep. De agent uit hoofdstuk 7 doet er meerdere, en wat hij bij de tweede aanroep verstuurt, hangt af van wat het model bij de eerste vroeg. Een test van de hele lus heeft een nep-client nodig die een gesprek naspeelt: eerst een antwoord dat om een tool vraagt, daarna een antwoord met het eigenlijke antwoord. FakeClient doet dat al, omdat hij zijn antwoorden op volgorde uitdeelt.

De agent die je test

Hoofdstuk 9 gaf de agent zijn definitieve vorm, in reliable.py:

run_agent(question, *, client, tools, system, approve, max_steps, budget, sleep)

Hij geeft een dictionary terug met answer, stop_reason, trace en messages. Elke stap van de trace is een dictionary met step, tokens, tool_calls en results. Elke aanroep gaat via call_model, dus die besteedt uit budget en wacht met sleep voordat hij opnieuw probeert.

Alles wat run_agent anders van het programma zou krijgen, levert de test zelf:

  • Een client: een FakeClient met de twee antwoorden.

  • Een tool: een kleine eigen functie van de test, onder een echte toolnaam, omdat describe_tools de beschrijving van elke tool opzoekt aan de hand van de naam. def read_note(arguments): return "Lists keep order." is genoeg. Die opent nooit een bestand, dus de test hangt niet af van de notities.

  • Een budget: een nieuw {"limit": 20000, "used": 0}, zodat de test kan controleren wat de run uitgaf.

  • Een goedkeuringsfunctie: refuse_all uit agent.py. Niets hier heeft goedkeuring nodig, maar run_agent vereist er een.

  • Een sleep: waits = [] en dan sleep=waits.append. De methode append van een lijst is een functie die één waarde krijgt, dezelfde vorm als time.sleep(seconds), dus je kunt hem als waarde doorgeven, zoals hoofdstuk 7 approve_all doorgaf. Als er iets opnieuw werd geprobeerd, zou de wachttijd in waits terechtkomen in plaats van de test te pauzeren.

Het gescripte gesprek

De twee antwoorden:

client = fakes.FakeClient(
    [
        fakes.tool_call_reply([("call_1", "read_note", '{"note_id": "03-lists"}')]),
        fakes.reply("Done."),
    ]
)

Bij de eerste aanroep vraagt het “model” om read_note met de argumenten {"note_id": "03-lists"}. run_agent voert jouw read_note uit en stuurt het resultaat terug. Bij de tweede aanroep antwoordt het Done. Elk nep-antwoord gebruikt de standaardwaarde usage=(10, 5), dus telt als 15 tokens.

De tekst van de argumenten is uitgeschreven als string, precies zoals een model die zou sturen. Zet er enkele aanhalingstekens omheen, zodat de dubbele aanhalingstekens erin niet ge-escapet hoeven te worden.

Nu jij

Schrijf in tests/test_agent.py een test die run_agent uitvoert met die client, jouw read_note in tools={"read_note": read_note}, een willekeurig systeembericht, approve=refuse_all, max_steps=6, een nieuw budget en sleep=waits.append. Controleer daarna met assertions dat:

  1. de stopreden "answered" is en het antwoord "Done.";

  2. de trace twee items heeft, en dat bij het eerste item tool_calls[0]["name"] gelijk is aan "read_note" en results gelijk is aan ["Lists keep order."];

  3. het tweede request, client.requests[1], de toolronde bevat: de messages zijn het systeembericht, de vraag, de assistant-beurt die om de tool vroeg en het toolbericht {"role": "tool", "tool_call_id": "call_1", "content": "Lists keep order."}, dus messages[2]["role"] is "assistant" en messages[3] is dat toolbericht;

  4. budget["used"] 30 is, twee antwoorden van 15 tokens;

  5. waits nog leeg is, dus dat er niets heeft gewacht.

Voer hem uit in de :

python -m pytest -q tests/test_agent.py
.                                                                        [100%]
1 passed in 0.23s

Eén test, één punt. Hij voerde de hele lus uit, twee modelaanroepen en een tool, in een fractie van een seconde, zonder netwerk en zonder wachten.

Waarom één test zoveel controleert

Elke assertion vangt een andere manier waarop de lus stuk kan gaan terwijl hij van buitenaf nog goed lijkt. Een lus die vergeet resultaten in de trace vast te leggen, antwoordt nog steeds. Een lus die het toolbericht nooit terugstuurt, krijgt van deze nep-client nog steeds Done., omdat de nep-client niet leest wat hij krijgt; alleen het vastgelegde request laat het gat zien. Een lus die vergeet tokens te tellen, antwoordt correct en geeft niets uit, tot er een echte rekening komt.

Bij het controleren van je werk wordt tests/test_agent.py uitgevoerd tegen de correcte run_agent en tegen vier kapotte versies, en je test moet op elke versie falen:

  • de toolresultaten ontbreken in de trace;

  • het antwoord komt terug als "";

  • het resultaat van de tool wordt niet teruggestuurd naar het model;

  • het verbruik (usage) van de antwoorden wordt niet bij het budget opgeteld.

Een kapotte run_agent voert de tool uit, maar stuurt het resultaat nooit terug naar het model. Welke assertion vangt dat?

Waarom geeft de test sleep=waits.append mee aan run_agent?

Opdracht

Schrijf in tests/test_agent.py een test die run_agent uit reliable.py aanstuurt met fakes.FakeClient([fakes.tool_call_reply([("call_1", "read_note", '{"note_id": "03-lists"}')]), fakes.reply("Done.")]), een eigen toolfunctie, def read_note(arguments): return "Lists keep order.", in tools={"read_note": read_note}, approve=refuse_all, max_steps=6, een nieuwe budgetdictionary en sleep=waits.append met waits = []. Controleer met assertions dat:

  1. de stopreden "answered" is en het antwoord "Done.";

  2. de trace twee items heeft; het eerste heeft de naam van de aanroep in tool_calls en ["Lists keep order."] als results;

  3. in client.requests[1]["messages"] item 2 de assistant-beurt is en item 3 het toolbericht met tool_call_id "call_1" en het resultaat van je tool;

  4. budget["used"] 30 is;

  5. waits leeg is.

Voer hem uit met python -m pytest -q tests/test_agent.py en controleer daarna je werk.