0%

Tools · Übung

Die Anfrage prüfen, bevor etwas läuft

Die Demonstration in Lektion 5 endete damit, dass ein einziger fehlerhafter Tool-Aufruf dein ganzes Programm angehalten hat. Das Modell hat eine Notiz namens 99-magic angefordert, read_note hat ValueError ausgelöst, und run_tool hat ihn durchgelassen. An deinem Programm war nichts falsch. Das Modell hat einen Fehler gemacht, und Modelle machen Fehler: Sie fordern Tools an, die es nicht gibt, schreiben Argumente, die kein gültiges JSON sind, oder lassen ein Argument weg.

Das Modell hat den Namen gewählt und die Argumente geschrieben, also prüft dein Programm beides, bevor irgendetwas läuft. Wenn eine Prüfung fehlschlägt, hält das Programm nicht an. Es schickt dem Modell eine Fehlermeldung als Ergebnis des Tools zurück, und das Modell kann sie lesen und etwas anderes versuchen oder dem Nutzer sagen, was schiefgegangen ist.

Vier Arten, wie eine Anfrage fehlerhaft sein kann

BAD_CALLS weit unten in tools.py enthält von jeder Art ein Beispiel, von Hand geschrieben in derselben Form, die read_tool_calls zurückgibt:

AufrufWas falsch istWas run_tool zurückgibt
delete_note mit '{"note_id": "03-lists"}'kein Tool hat diesen NamenError: there is no tool called delete_note. The tools are: list_notes, read_note.
read_note mit '{"note_id": 'die Argumente sind kein gültiges JSONError: the arguments are not valid JSON.
read_note mit '["03-lists"]'gültiges JSON, aber eine Liste, kein ObjektError: the arguments must be a JSON object.
read_note mit '{}'das Tool selbst lehnt abError: read_note needs a note_id string, such as 03-lists.

Der Aufruf mit 99-magic gehört ebenfalls zur letzten Art: read_note löst ValueError mit seiner eigenen Meldung aus, und run_tool reicht diese Meldung weiter.

Das neue run_tool

run_tool(call, tools) geht jetzt fünf Schritte durch, in dieser Reihenfolge:

  1. Der Name. Wenn call["name"] kein Schlüssel von tools ist, gib f"Error: there is no tool called {name}. The tools are: {names}." zurück, wobei names die Tool-Namen sind, verbunden mit ", ". Das erledigt ", ".join(tools): Wer über ein Dictionary iteriert, wie join es tut, bekommt seine Schlüssel, in der Reihenfolge, in der sie hinzugefügt wurden. Die echten Namen aufzulisten gibt dem Modell, was es für einen neuen Versuch braucht.

  2. Das JSON. Dekodiere call["arguments"] mit json.loads innerhalb eines try. Wenn dabei json.JSONDecodeError ausgelöst wird, gib "Error: the arguments are not valid JSON." zurück.

  3. Der Typ. Wenn der dekodierte Wert kein Dictionary ist (isinstance(arguments, dict)), gib "Error: the arguments must be a JSON object." zurück. Text wie '["03-lists"]', '"03-lists"' oder 'null' ist gültiges JSON, aber jedes Tool erwartet ein Dictionary.

  4. Das Tool. Rufe das Tool in einem zweiten try auf. Wenn es ValueError auslöst, gib f"Error: {error}" zurück, was die eigene Meldung des Tools hinter Error: setzt.

  5. Das Ergebnis. Andernfalls gib zurück, was das Tool zurückgegeben hat.

Die Schritte 1 bis 3 laufen, bevor das Tool aufgerufen wird. Ein falscher Name oder fehlerhaftes JSON erreicht also nie ein Tool.

Zwei try-Blöcke, nicht einer

Es ist verlockend, alles in ein einziges try zu packen und ValueError abzufangen. Das funktioniert nicht, denn json.JSONDecodeError ist selbst eine Art von ValueError:

import json

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

Mit einem einzigen try würde ein JSON-Fehler im except ValueError des Tools landen und als Error: Expecting value: line 1 column 13 (char 12) zurückkommen, eine Meldung über den Decoder statt über die Anfrage. Wenn du except json.JSONDecodeError zuerst aufführst, rettet das ein einzelnes try nicht ganz. Ein Tool kann selbst JSONDecodeError auslösen, zum Beispiel beim Lesen einer JSON-Datei, und das würde dem Modell als fehlerhafte Argumente gemeldet. Ein try nur um json.loads fängt nur den Fehler des Modells ab. Das Dekodieren in einem eigenen try, bevor das Tool läuft, hält die beiden Probleme auseinander.

Was das Programm weiterhin anhält

run_tool fängt JSONDecodeError beim Dekodieren und ValueError beim Tool ab, und sonst nichts. Wenn ein Tool KeyError oder TypeError auslöst, ist das kein Fehler des Modells: Es ist ein Bug im Code des Tools, und den willst du sehen, als Traceback, während du ihn behebst. Würdest du jede Ausnahme abfangen, ginge dein eigener Bug an das Modell, als hätte das Modell etwas falsch gemacht, und du würdest es vielleicht nie bemerken.

Die mitgelieferten Tools halten sich an diese Regel. read_note löst für jedes Problem, das ein Modell verursachen kann, ValueError aus, mit einer Meldung, die für das Modell geschrieben ist, und alles andere, was es auslösen würde, wäre ein Bug.

Ausführen

Führe python tools.py aus. Die Demonstration fragt noch einmal What does the note 99-magic say?, schickt dein Fehlerergebnis an das Modell zurück und übergibt dann jeden Aufruf in BAD_CALLS an dein 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.

Das Programm ist weitergelaufen. Das Modell hat ein Fehlerergebnis bekommen, und seine Antwort sagt dem Nutzer, was passiert ist, statt dass das Programm abstürzt. Diese Antwort ist fest, wie immer beim geskripteten Modell; ein Live-Modell würde den Fehler lesen und vielleicht list_notes aufrufen, um nach einer besseren ID zu suchen, was die Schleife in Kapitel 7 möglich macht.

Ein Lernender packt json.loads und den Tool-Aufruf in ein einziges try mit except ValueError as error: return f"Error: {error}". Was passiert mit einem Aufruf, dessen Argumente '{"note_id": ' sind?

Ein Tool hat einen Bug und löst KeyError aus. Warum sollte run_tool ihn durchlassen, statt Error: ... an das Modell zurückzugeben?

Warum prüft run_tool nach dem Dekodieren isinstance(arguments, dict)?

Aufgabe

Ändere in tools.py run_tool(call, tools) so, dass eine fehlerhafte Anfrage einen Fehler-String zurückgibt, statt das Programm anzuhalten. In dieser Reihenfolge:

  1. Wenn call["name"] nicht in tools ist, gib f"Error: there is no tool called {name}. The tools are: {names}." zurück, mit den Namen aus tools, verbunden durch ", ", in der Reihenfolge des Dictionarys.

  2. Dekodiere call["arguments"] in einem eigenen try. Bei json.JSONDecodeError gib "Error: the arguments are not valid JSON." zurück.

  3. Wenn der dekodierte Wert kein Dictionary ist, gib "Error: the arguments must be a JSON object." zurück.

  4. Rufe das Tool in einem zweiten try auf. Bei ValueError gib f"Error: {error}" zurück.

  5. Andernfalls gib das Ergebnis des Tools zurück.

Rufe das Tool nicht auf, wenn der Name oder die Argumente fehlerhaft sind, und fange keine andere Ausnahme ab: Ein KeyError oder TypeError aus einem Tool muss beim Aufrufer ankommen. Führe python tools.py aus, um zu sehen, wie die fehlerhaften Aufrufe mit Fehlern beantwortet werden, und prüfe dann deine Arbeit.