0%

Tools · oefening

Controleer de toolaanroep voordat je iets uitvoert

De demonstratie van les 5 eindigde ermee dat één slechte toolaanroep je hele programma stopte. Het model vroeg om een notitie met de naam 99-magic, read_note wierp ValueError op en run_tool liet die door. Er was niets mis met je programma. Het model maakte een fout, en dat doen modellen: ze vragen om tools die niet bestaan, schrijven argumenten die geen geldige JSON zijn, of laten een argument weg.

Het model koos de naam en schreef de argumenten, dus je programma controleert beide voordat er iets draait. Als een controle faalt, stopt het programma niet. Het stuurt een foutmelding terug naar het model als resultaat van de tool, en het model kan die lezen en iets anders proberen, of de gebruiker vertellen wat er misging.

Vier manieren waarop een toolaanroep fout kan zijn

BAD_CALLS onderaan in tools.py bevat van elke soort één, met de hand geschreven in dezelfde vorm die read_tool_calls teruggeeft:

AanroepWat er mis isWat run_tool teruggeeft
delete_note met '{"note_id": "03-lists"}'er is geen tool met die naamError: there is no tool called delete_note. The tools are: list_notes, read_note.
read_note met '{"note_id": 'de argumenten zijn geen geldige JSONError: the arguments are not valid JSON.
read_note met '["03-lists"]'geldige JSON, maar een lijst, geen objectError: the arguments must be a JSON object.
read_note met '{}'de tool zelf weigertError: read_note needs a note_id string, such as 03-lists.

De aanroep met 99-magic is ook van de laatste soort: read_note werpt ValueError op met een eigen bericht, en run_tool geeft dat bericht door.

De nieuwe run_tool

run_tool(call, tools) doorloopt nu vijf stappen, in deze volgorde:

  1. De naam. Als call["name"] geen sleutel van tools is, geef je f"Error: there is no tool called {name}. The tools are: {names}." terug, waarbij names de toolnamen zijn, samengevoegd met ", ". ", ".join(tools) doet dat: over een dictionary lopen, zoals join doet, geeft de sleutels, in de volgorde waarin ze zijn toegevoegd. Door de echte namen op te sommen krijgt het model wat het nodig heeft om het opnieuw te proberen.

  2. De JSON. Decodeer call["arguments"] met json.loads binnen een try. Als dat json.JSONDecodeError opwerpt, geef je "Error: the arguments are not valid JSON." terug.

  3. Het type. Als de gedecodeerde waarde geen dictionary is (isinstance(arguments, dict)), geef je "Error: the arguments must be a JSON object." terug. Tekst zoals '["03-lists"]', '"03-lists"' of 'null' is geldige JSON, maar elke tool verwacht één dictionary.

  4. De tool. Roep de tool aan in een tweede try. Als die ValueError opwerpt, geef je f"Error: {error}" terug, wat het eigen bericht van de tool achter Error: zet.

  5. Het resultaat. Geef anders terug wat de tool teruggaf.

Stap 1 tot en met 3 draaien voordat de tool wordt aangeroepen, dus een slechte naam of slechte JSON bereikt nooit een tool.

Twee try-blokken, niet één

Het is verleidelijk om alles in één try te zetten en ValueError af te vangen. Dat werkt niet, omdat json.JSONDecodeError zelf een soort ValueError is:

import json

try:
    json.loads('{"note_id": ')
except ValueError as error:
    print(type(error).__name__, "is a ValueError:", isinstance(error, ValueError))

Met één try zou een JSON-fout in de except ValueError van de tool belanden en terugkomen als Error: Expecting value: line 1 column 13 (char 12), een bericht over de decoder in plaats van over de toolaanroep. Door except json.JSONDecodeError eerst te zetten los je het probleem met één try niet helemaal op. Een tool kan zelf JSONDecodeError opwerpen, bijvoorbeeld bij het lezen van een JSON-bestand, en dat zou aan het model worden gemeld als slechte argumenten. Een try om alleen json.loads vangt alleen de fout van het model af. Door in een eigen try te decoderen, voordat de tool draait, houd je de twee problemen gescheiden.

Wat het programma nog steeds stopt

run_tool vangt JSONDecodeError af rond het decoderen en ValueError rond de tool, en verder niets. Als een tool KeyError of TypeError opwerpt, is dat niet de fout van het model: het is een bug in de code van de tool, en die wil je zien, als traceback, terwijl je hem oplost. Als je elke exception afvangt, stuur je je eigen bug naar het model alsof het model iets fout deed, en merk je hem misschien nooit op.

De meegeleverde tools volgen die regel. read_note werpt ValueError op voor elk probleem dat een model kan veroorzaken, met een bericht dat voor het model is geschreven, en elke andere exception die hij zou opwerpen, zou een bug zijn.

Voer het uit

Voer python tools.py uit. De demonstratie vraagt opnieuw What does the note 99-magic say?, stuurt je foutresultaat terug naar het model en geeft daarna elke aanroep in BAD_CALLS aan je run_tool:

A request for a note that does not exist:
[{'id': 'call_1_1', 'name': 'read_note', 'arguments': '{"note_id": "99-magic"}'}]
Result: Error: There is no note called 99-magic. Call list_notes to see the ids.
Answer: I couldn't find a note called 99-magic. The notes run from 01-variables to 12-testing.
The calls in BAD_CALLS:
delete_note {"note_id": "03-lists"} -> Error: there is no tool called delete_note. The tools are: list_notes, read_note.
read_note {"note_id":  -> Error: the arguments are not valid JSON.
read_note ["03-lists"] -> Error: the arguments must be a JSON object.
read_note {} -> Error: read_note needs a note_id string, such as 03-lists.
Two calls in one reply:
[{'id': 'call_1_1', 'name': 'read_note', 'arguments': '{"note_id": "03-lists"}'}, {'id': 'call_1_2', 'name': 'read_note', 'arguments': '{"note_id": "06-dictionaries"}'}]
Run stopped at the next function to build: tool_messages is built in Lesson 7.

Het programma ging door. Het model kreeg een foutresultaat, en zijn antwoord vertelt de gebruiker wat er gebeurde in plaats van dat het programma crasht. Dat antwoord ligt vast, zoals altijd bij het gescripte model; een live model zou de fout lezen en misschien list_notes aanroepen om een beter id te zoeken, wat de lus van hoofdstuk 7 mogelijk maakt.

Een leerling zet json.loads en de toolaanroep in één try met except ValueError as error: return f"Error: {error}". Wat gebeurt er met een aanroep waarvan de argumenten '{"note_id": ' zijn?

Een tool heeft een bug en werpt KeyError op. Waarom moet run_tool die doorlaten in plaats van Error: ... terug te geven aan het model?

Waarom controleert run_tool isinstance(arguments, dict) na het decoderen?

Opdracht

Verander run_tool(call, tools) in tools.py zo dat een slechte toolaanroep een foutstring teruggeeft in plaats van het programma te stoppen. In deze volgorde:

  1. Als call["name"] niet in tools staat, geef je f"Error: there is no tool called {name}. The tools are: {names}." terug, met de namen van tools samengevoegd met ", " in de volgorde van de dictionary.

  2. Decodeer call["arguments"] in een eigen try. Bij json.JSONDecodeError geef je "Error: the arguments are not valid JSON." terug.

  3. Als de gedecodeerde waarde geen dictionary is, geef je "Error: the arguments must be a JSON object." terug.

  4. Roep de tool aan in een tweede try. Bij ValueError geef je f"Error: {error}" terug.

  5. Geef anders het resultaat van de tool terug.

Roep de tool niet aan als de naam of de argumenten fout zijn, en vang geen andere exception af: een KeyError of TypeError uit een tool moet de aanroeper bereiken. Voer python tools.py uit om de slechte aanroepen met foutmeldingen beantwoord te zien, en controleer daarna je werk.