Claude Architect · Les

PostToolUse- en outgoing-call-hooks

onderschep toolresultaten en blokkeer acties die beleid schenden

Les 1 van 413 stappen

PostToolUse- en outgoing-call-hooks is een gratis Claude Architect-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Claude Architect. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Claude Architect bevat in totaal 4 lessen.

Waarom hooks bestaan

Prompts sturen het model aan, maar zijn probabilistisch — ongeveer 90% betrouwbaar. Voor het meeste gedrag is dat voldoende. Sommige acties mogen echter nooit doorglippen: een grote terugbetaling uitvoeren, productiegegevens verwijderen of geld versturen.

Hooks zorgen voor 100% deterministische handhaving. Het zijn stukken code die rond de uitvoering van hulpmiddelen draaien, buiten de beslissingsruimte van het model. Gebruik hooks wanneer een fout financiële, juridische of veiligheidsgevolgen heeft.

Twee hookpunten die je moet kennen

Deze les behandelt twee handhavingspunten:

  • PostToolUse — wordt nadat een hulpmiddel is uitgevoerd geactiveerd en onderschept het resultaat voordat het model het ziet. Je kunt de uitvoer van het hulpmiddel inkorten, valideren, anonimiseren of hervormen.
  • Hooks voor uitgaande aanroepen — blokkeren een actie die het beleid schendt voordat deze je systeem verlaat (bijvoorbeeld een terugbetaling boven een drempelbedrag).

Samen omvatten ze het gevaarlijke deel van de agentische lus: het moment waarop een resultaat van een hulpmiddel het gesprek binnenkomt en het moment waarop een neveneffect het gesprek zou verlaten.

Waar hooks zich in de lus bevinden

Denk terug aan de agentische lus: verzoek verzenden, stop_reason inspecteren en, wanneer dit tool_use is, het hulpmiddel uitvoeren en het resultaat aan de geschiedenis toevoegen; daarna herhalen tot end_turn.

Een PostToolUse-hook omhult die stap waarin je het hulpmiddel uitvoert. Het model vraagt een aanroep van een hulpmiddel aan; je code voert deze uit; voordat je het resultaat aan de berichtgeschiedenis toevoegt, inspecteert de hook het resultaat en kan deze het aanpassen.

def run_tool_with_hook(tool_name, tool_input, tool_use_id):
    raw_result = execute_tool(tool_name, tool_input)
    # PostToolUse: inspect/transform BEFORE the model sees it
    safe_result = post_tool_use_hook(tool_name, raw_result)
    return {
        "type": "tool_result",
        "tool_use_id": tool_use_id,
        "content": safe_result,
    }

PostToolUse: uitgebreide uitvoer inkorten

Een veelvoorkomende, praktische taak van PostToolUse is de uitvoer van een hulpmiddel inkorten tot de relevante velden. Ruwe API-reacties zijn vaak enorm en opgeblazen context veroorzaakt het lost-in-the-middle-probleem — modellen letten meer op het begin en einde van de context dan op het midden.

De hook hervormt het resultaat deterministisch, zodat het model alleen de velden ziet die ertoe doen.

def post_tool_use_hook(tool_name, raw_result):
    if tool_name == "lookup_order":
        # Keep only fields the model needs; drop the rest
        return {
            "order_id": raw_result["id"],
            "status": raw_result["status"],
            "total": raw_result["total"],
        }
    return raw_result

PostToolUse: gestructureerde fouten, geen algemene

PostToolUse is ook de plaats waar je fouten normaliseert. Een algemene status zoals "Operation failed" blokkeert herstel — het model kan een tijdelijke fout niet onderscheiden van een autorisatieprobleem.

Hervorm fouten tot gestructureerde fouten, zodat het model intelligent kan doorsturen: een vlag, een categorie, informatie over opnieuw proberen en context.

def post_tool_use_hook(tool_name, raw_result):
    if raw_result.get("error"):
        return {
            "isError": True,
            "errorCategory": "transient",   # transient/validation/business/permission
            "isRetryable": True,
            "message": raw_result["error"],
            "attempted_query": raw_result.get("query"),
            "partial_results": raw_result.get("partial", []),
        }
    return raw_result

Fout onderscheiden van leeg resultaat

Een subtiele regel die PostToolUse helpt afdwingen: een toegangsprobleem is niet hetzelfde als een geldig leeg resultaat.

  • Een mislukte query (time-out, authenticatie) is een fout die het model opnieuw kan proberen.
  • Een leeg resultaat (nul overeenkomende bestellingen) is een legitiem antwoord — opnieuw proberen verandert niets.

Leg dit verschil vast, zodat het model nooit iteraties verspilt aan het opnieuw uitvoeren van een query die simpelweg geen overeenkomsten heeft.

def post_tool_use_hook(tool_name, raw_result):
    if tool_name == "lookup_order":
        if raw_result.get("connection_error"):
            return {"isError": True, "errorCategory": "transient",
                    "isRetryable": True}
        # Empty is a VALID answer, not an error
        return {"orders": raw_result.get("orders", []),
                "isError": False}
    return raw_result

Hooks voor uitgaande aanroepen: de harde stop

Nu het belangrijkste toepassingsgebied. In het scenario Customer Support van het examen is er een hulpmiddel process_refund. Het beleid luidt: voor terugbetalingen boven $500 is een medewerker nodig.

Je zou die regel in de prompt kunnen schrijven — maar een prompt is ongeveer 90% betrouwbaar en één gemiste terugbetaling betekent een echt financieel verlies. Daarom omhul je de uitgaande aanroep met een hook die deterministisch blokkeert wanneer de drempel wordt overschreden. Het oordeel van het model krijgt hier geen stem.

REFUND_LIMIT = 500

def outgoing_call_hook(tool_name, tool_input):
    if tool_name == "process_refund" and tool_input["amount"] > REFUND_LIMIT:
        # Block the side effect; hand control back to the model
        return {
            "blocked": True,
            "reason": "Refund over $500 requires human approval.",
            "next_action": "escalate_to_human",
        }
    return execute_tool(tool_name, tool_input)

Programmatische voorwaarden vooraf

Hooks voor uitgaande aanroepen dwingen ook voorwaarden vooraf af — volgordegaranties die een prompt niet betrouwbaar kan bieden. Voorbeeld: verwerk nooit een terugbetaling voordat get_customer een geverifieerde identiteit heeft geretourneerd.

De hook controleert een feit in je eigen status, niet de bewering van het model dat het dit 'al heeft geverifieerd'. Dat is het verschil tussen een deterministische garantie en een hoopvolle instructie.

def outgoing_call_hook(tool_name, tool_input, session_state):
    if tool_name == "process_refund" and not session_state.get("verified_customer_id"):
        return {
            "blocked": True,
            "reason": "Identity not verified. Call get_customer first.",
        }
    return execute_tool(tool_name, tool_input)

Geef de blokkering terug aan het model

Blokkeren is slechts de helft van het werk. Een hook die de actie stilzwijgend inslikt, laat het model in verwarring achter en legt de lus stil — dat is stilzwijgende onderdrukking, een antipatron.

Geef de blokkering in plaats daarvan terug als een resultaat van een hulpmiddel dat het model kan lezen en waarop het kan handelen. Een goede blokkeerboodschap vermeldt de reden en de juiste volgende stap (hier: escalate_to_human), zodat de agent zich binnen dezelfde lus netjes herstelt.

def handle_tool_call(tool_name, tool_input, tool_use_id, state):
    outcome = outgoing_call_hook(tool_name, tool_input, state)
    if isinstance(outcome, dict) and outcome.get("blocked"):
        return {"type": "tool_result", "tool_use_id": tool_use_id,
                "is_error": True, "content": outcome["reason"]}
    return {"type": "tool_result", "tool_use_id": tool_use_id,
            "content": outcome}

Hooks versus iteratielimieten

Verwar handhavingshooks niet met het vangnet van de lus. Een iteratielimiet stopt een lus die op hol slaat, maar is een noodrem — nooit het primaire besturingsmechanisme en nooit een vervanging voor handhaving van beleid.

Hooks zijn het tegenovergestelde: een precieze, bewuste garantie voor een specifieke actie. Het model blijft beslissingen nemen; hooks reserveren harde code alleen voor garanties die er echt toe doen.

Wanneer je een hook gebruikt

Beslisregel voor het examen en voor productie:

  • Gebruik een hook wanneer een fout financiële, juridische of veiligheidskritieke gevolgen heeft, of wanneer je een deterministische voorwaarde vooraf of drempel nodig hebt (terugbetaling > $500, geverifieerde identiteit vóór uitbetaling).
  • Gebruik een prompt voor algemene aanwijzingen, toon en de ongeveer 90% van het gedrag waarbij een incidentele fout acceptabel is.

Hooks = deterministisch. Prompts = probabilistisch. Stem het hulpmiddel af op de kosten van een fout.

Korte controle

Een ondersteuningsagent heeft een hulpmiddel process_refund. Het bedrijfsbeleid: terugbetalingen boven $500 moeten door een medewerker worden goedgekeurd. De meeste terugbetalingen zijn klein en worden automatisch uitgevoerd. Wat is de architectuurwaardige manier om dit af te dwingen?

Samenvatting

Belangrijkste punten:

  • PostToolUse onderschept resultaten van hulpmiddelen voordat het model ze ziet — kort uitgebreide uitvoer in, normaliseer algemene fouten tot gestructureerde fouten en onderscheid toegangsproblemen van geldige lege resultaten.
  • Hooks voor uitgaande aanroepen blokkeren acties die het beleid schenden (terugbetaling > $500) en dwingen voorwaarden vooraf af (geverifieerde identiteit vóór uitbetaling).
  • Hooks = 100% deterministisch; prompts = ongeveer 90% probabilistisch. Gebruik hooks wanneer een fout financiële, juridische of veiligheidskritieke gevolgen heeft.
  • Geef een blokkering altijd terug als een gestructureerd resultaat — onderdruk deze nooit stilzwijgend. Iteratielimieten zijn een vangnet, geen handhaving.
Gratis beginnen

Leer Python met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
26
Lessen
104

Veelgestelde vragen

Is de les “PostToolUse- en outgoing-call-hooks” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Claude Architect, waaronder “PostToolUse- en outgoing-call-hooks”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Claude Architect bevat in totaal 4 lessen.

Wat leer ik in “PostToolUse- en outgoing-call-hooks”?

onderschep toolresultaten en blokkeer acties die beleid schenden Je oefent met Claude Architect door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Claude Architect te beginnen?

Ervaring vooraf is niet nodig. Claude Architect op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “PostToolUse- en outgoing-call-hooks”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Claude Architect?

Ja. Elke les over Claude Architect bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. PostToolUse- en outgoing-call-hooks
  2. Deterministische afdwinging versus prompts
  3. Programmatische randvoorwaarden
  4. Gestructureerde overdrachtsprotocollen
← Terug naar Claude Architect