0%

LLM-Code testen · Übung

Die Agentenschleife mit geskripteten Antworten testen

ask macht einen Aufruf. Der Agent aus Kapitel 7 macht mehrere, und was er beim zweiten Aufruf sendet, hängt davon ab, worum das Modell beim ersten gebeten hat. Ein Test der ganzen Schleife braucht einen Fake, der ein Gespräch durchspielt: zuerst eine Antwort, die ein Tool anfordert, dann eine Antwort mit dem Ergebnis. FakeClient kann das bereits, weil er seine Antworten der Reihe nach herausgibt.

Der Agent, den du testest

Kapitel 9 hat dem Agenten seine endgültige Form gegeben, in reliable.py:

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

Er gibt ein Dictionary mit answer, stop_reason, trace und messages zurück. Jeder Schritt im Trace ist ein Dictionary mit step, tokens, tool_calls und results. Jeder Aufruf läuft über call_model, er verbraucht also vom budget und wartet vor einem erneuten Versuch mit sleep.

Alles, was run_agent sonst vom Programm bekommen würde, liefert der Test selbst:

  • Einen Client: einen FakeClient mit den beiden Antworten.

  • Ein Tool: eine kleine eigene Funktion des Tests unter einem echten Tool-Namen, weil describe_tools die Beschreibung jedes Tools über seinen Namen nachschlägt. def read_note(arguments): return "Lists keep order." genügt. Sie öffnet nie eine Datei, also hängt der Test nicht von den Notizen ab.

  • Ein Budget: ein frisches {"limit": 20000, "used": 0}, damit der Test prüfen kann, was der Lauf verbraucht hat.

  • Eine Genehmigungsfunktion: refuse_all aus agent.py. Hier braucht nichts eine Genehmigung, aber run_agent verlangt eine.

  • Ein Sleep: waits = [] und dann sleep=waits.append. Die Methode append einer Liste ist eine Funktion, die einen Wert annimmt, dieselbe Form wie time.sleep(seconds), also kannst du sie als Wert übergeben, so wie Kapitel 7 approve_all übergeben hat. Würde irgendetwas erneut versucht, landete die Wartezeit in waits, statt den Test anzuhalten.

Das geskriptete Gespräch

Die beiden Antworten:

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

Beim ersten Aufruf fordert das „Modell“ read_note mit den Argumenten {"note_id": "03-lists"} an. run_agent führt dein read_note aus und sendet das Ergebnis zurück. Beim zweiten Aufruf antwortet es Done. Jede Fake-Antwort verwendet das Standard-usage=(10, 5), zählt also 15 Tokens.

Der Argumenttext ist als String ausgeschrieben, genau so, wie ein Modell ihn senden würde. Schreib ihn außen mit einfachen Anführungszeichen, dann brauchen die doppelten Anführungszeichen innen kein Escaping.

Jetzt du

Schreibe in tests/test_agent.py einen Test, der run_agent mit diesem Client, deinem read_note in tools={"read_note": read_note}, einer beliebigen Systemnachricht, approve=refuse_all, max_steps=6, einem frischen Budget und sleep=waits.append ausführt. Prüfe dann, dass:

  1. der Stoppgrund "answered" und die Antwort "Done." ist;

  2. der Trace zwei Einträge hat und beim ersten tool_calls[0]["name"] gleich "read_note" und results gleich ["Lists keep order."] ist;

  3. die zweite Anfrage, client.requests[1], die Tool-Runde enthält: Ihre messages sind die Systemnachricht, die Frage, die Assistant-Runde, die das Tool angefordert hat, und die Tool-Nachricht {"role": "tool", "tool_call_id": "call_1", "content": "Lists keep order."}, also ist messages[2]["role"] gleich "assistant" und messages[3] diese Tool-Nachricht;

  4. budget["used"] gleich 30 ist, zwei Antworten mit je 15 Tokens;

  5. waits immer noch leer ist, also nichts gewartet hat.

Führe ihn im aus:

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

Ein Test, ein Punkt. Er hat die ganze Schleife durchlaufen, zwei Modellaufrufe und ein Tool, in einem Bruchteil einer Sekunde, ohne Netzwerk und ohne Warten.

Warum ein Test so viel prüft

Jede Zusicherung erwischt eine andere Art, wie die Schleife kaputtgehen könnte, während sie von außen weiterhin gut aussieht. Eine Schleife, die vergisst, Ergebnisse im Trace festzuhalten, antwortet trotzdem. Eine Schleife, die die Tool-Nachricht nie zurücksendet, bekommt von diesem Fake trotzdem Done., weil der Fake nicht liest, was ihm gesendet wird; nur die aufgezeichnete Anfrage zeigt die Lücke. Eine Schleife, die vergisst, Tokens zu zählen, antwortet richtig und verbraucht nichts, bis eine echte Rechnung kommt.

Die Prüfung deiner Arbeit führt tests/test_agent.py gegen das korrekte run_agent und gegen vier kaputte Versionen aus, und dein Test muss bei jeder fehlschlagen:

  • die Tool-Ergebnisse fehlen im Trace;

  • die Antwort kommt als "" zurück;

  • das Ergebnis des Tools wird nicht an das Modell zurückgesendet;

  • die Usage der Antworten wird nicht zum Budget addiert.

Ein kaputtes run_agent führt das Tool aus, sendet sein Ergebnis aber nie an das Modell zurück. Welche Zusicherung erwischt das?

Warum übergibt der Test sleep=waits.append an run_agent?

Aufgabe

Schreibe in tests/test_agent.py einen Test, der run_agent aus reliable.py mit fakes.FakeClient([fakes.tool_call_reply([("call_1", "read_note", '{"note_id": "03-lists"}')]), fakes.reply("Done.")]) antreibt, mit einer eigenen Tool-Funktion def read_note(arguments): return "Lists keep order." in tools={"read_note": read_note}, approve=refuse_all, max_steps=6, einem frischen Budget-Dictionary und sleep=waits.append mit waits = []. Prüfe, dass:

  1. der Stoppgrund "answered" und die Antwort "Done." ist;

  2. der Trace zwei Einträge hat; der erste hat den Namen des Aufrufs in tool_calls und ["Lists keep order."] als results;

  3. in client.requests[1]["messages"] Element 2 die Assistant-Runde und Element 3 die Tool-Nachricht mit tool_call_id "call_1" und dem Ergebnis deines Tools ist;

  4. budget["used"] gleich 30 ist;

  5. waits leer ist.

Führe ihn mit python -m pytest -q tests/test_agent.py aus und prüfe dann deine Arbeit.