Claude Architect · บทเรียน

PostToolUse และฮุกสำหรับการเรียกออก

ดักรับผลลัพธ์จากเครื่องมือและบล็อกการกระทำที่ละเมิดนโยบาย

บทเรียน 1 จาก 413 ขั้นตอน

PostToolUse และฮุกสำหรับการเรียกออก เป็นบทเรียน Claude Architect ฟรีบน CoddyKit นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Claude Architect และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Claude Architect มีบทเรียนทั้งหมด 4 บทเรียน

เหตุผลที่มีฮุก

คำสั่งช่วยชี้นำโมเดล แต่เป็นสิ่งที่ อาศัยความน่าจะเป็น — มีความน่าเชื่อถือประมาณ 90% สำหรับพฤติกรรมส่วนใหญ่ นั่นถือว่าเพียงพอ แต่การดำเนินการบางอย่างต้องไม่เล็ดลอดโดยเด็ดขาด เช่น การคืนเงินจำนวนมาก การลบข้อมูลในระบบจริง หรือการโอนเงิน

ฮุกช่วยบังคับใช้ได้อย่าง แน่นอน 100% ฮุกคือโค้ดที่ทำงานล้อมรอบการเรียกใช้เครื่องมือ โดยอยู่นอกเหนือดุลยพินิจของโมเดล ให้ใช้ฮุกเมื่อความล้มเหลวมีผลกระทบด้าน การเงิน กฎหมาย หรือความปลอดภัย

จุดฮุกสองจุดที่ควรรู้

บทเรียนนี้ครอบคลุมจุดบังคับใช้สองจุด:

PostToolUse — ทำงาน หลังจากเครื่องมือทำงานเสร็จ และดักผลลัพธ์ไว้ ก่อนที่โมเดลจะเห็น คุณสามารถตัดทอน ตรวจสอบความถูกต้อง ปกปิดข้อมูล หรือปรับรูปแบบผลลัพธ์จากเครื่องมือได้
ฮุกการเรียกขาออก — บล็อกการดำเนินการที่ละเมิดนโยบาย ก่อนที่การดำเนินการนั้นจะออกจากระบบของคุณ (เช่น การคืนเงินเกินเกณฑ์ที่กำหนด)

เมื่อทำงานร่วมกัน ฮุกทั้งสองจะครอบคลุมส่วนที่อันตรายของลูปของผู้ช่วย ได้แก่ ช่วงเวลาที่ผลลัพธ์จากเครื่องมือเข้าสู่บทสนทนา และช่วงเวลาที่ผลกระทบภายนอกกำลังจะออกจากระบบ

ตำแหน่งของฮุกในลูป

โปรดทบทวนลูปของผู้ช่วย: ส่งคำขอ ตรวจสอบ stop_reason และเมื่อเป็น tool_use ให้เรียกใช้เครื่องมือ เพิ่มผลลัพธ์ลงในประวัติ แล้วทำซ้ำจนกว่าจะเป็น end_turn

ฮุก PostToolUse จะครอบขั้นตอน "เรียกใช้เครื่องมือ" นั้น โมเดลร้องขอการเรียกใช้เครื่องมือ โค้ดของคุณดำเนินการ และ ก่อนเพิ่มผลลัพธ์ ลงในประวัติข้อความ ฮุกจะตรวจสอบและอาจแก้ไขผลลัพธ์

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: ตัดทอนผลลัพธ์ที่มีรายละเอียดมากเกินไป

งานที่พบได้บ่อยและใช้ได้จริงของ PostToolUse คือ ตัดทอนผลลัพธ์จากเครื่องมือให้เหลือเฉพาะเขตข้อมูลที่เกี่ยวข้อง การตอบกลับดิบจากส่วนเชื่อมต่อโปรแกรมมักมีขนาดใหญ่ และบริบทที่มากเกินไปทำให้เกิดปัญหา ข้อมูลตรงกลางถูกละเลย — โมเดลให้ความสนใจกับต้นและท้ายบริบทมากกว่าส่วนกลาง

ฮุกจะปรับรูปแบบผลลัพธ์อย่างแน่นอน ทำให้โมเดลเห็นเฉพาะเขตข้อมูลที่สำคัญเท่านั้น

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: ข้อผิดพลาดแบบมีโครงสร้าง ไม่ใช่ข้อผิดพลาดทั่วไป

PostToolUse ยังเป็นจุดที่คุณ ปรับข้อผิดพลาดให้อยู่ในรูปแบบมาตรฐาน สถานะทั่วไปอย่าง "Operation failed" ทำให้กู้คืนการทำงานได้ยาก — โมเดลไม่อาจแยกความขัดข้องชั่วคราวออกจากปัญหาสิทธิ์ได้

ปรับรูปแบบความล้มเหลวให้เป็น ข้อผิดพลาดที่มีโครงสร้าง เพื่อให้โมเดลเลือกเส้นทางได้อย่างเหมาะสม ได้แก่ ตัวบ่งชี้ หมวดหมู่ ความสามารถในการลองใหม่ และบริบท

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

แยกความล้มเหลวออกจากผลลัพธ์ว่าง

กฎละเอียดข้อหนึ่งที่ PostToolUse ช่วยบังคับใช้คือ การเข้าถึงล้มเหลวไม่เหมือนกับการได้ผลลัพธ์ว่างที่ถูกต้อง

คำค้นที่ล้มเหลว (หมดเวลา การยืนยันตัวตน) คือข้อผิดพลาดที่โมเดลอาจลองใหม่
ผลลัพธ์ว่าง (ไม่มีคำสั่งซื้อที่ตรงกัน) คือ คำตอบที่ถูกต้องตามปกติ — ลองใหม่ก็ไม่ทำให้เกิดการเปลี่ยนแปลง

ให้เข้ารหัสความแตกต่างนี้ เพื่อไม่ให้โมเดียลเสียรอบการทำงานไปกับการลองคำค้นใหม่ที่ไม่มีข้อมูลตรงกันตั้งแต่แรก

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

ฮุกการเรียกขาออก: การหยุดแบบเด็ดขาด

ต่อไปคือกรณีการใช้งานสำคัญที่สุด เครื่องมือในสถานการณ์ฝ่ายสนับสนุนลูกค้าของข้อสอบคือ process_refund นโยบายคือ การคืนเงินเกิน $500 ต้องให้มนุษย์ดำเนินการ

คุณอาจเขียนกฎนี้ไว้ในคำสั่ง แต่คำสั่งมีความน่าเชื่อถือประมาณ 90% และการคืนเงินที่พลาดเพียงครั้งเดียวก็สร้างความเสียหายทางการเงินจริง ดังนั้นให้ครอบการเรียกขาออกด้วยฮุกที่ บล็อกอย่างแน่นอน เมื่อเกินเกณฑ์ โมเดลไม่มีสิทธิ์ลงความเห็นในกรณีนี้

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)

เงื่อนไขก่อนดำเนินการด้วยโปรแกรม

ฮุกการเรียกขาออกยังบังคับใช้ เงื่อนไขก่อนดำเนินการ ซึ่งเป็นหลักประกันด้านลำดับที่คำสั่งไม่อาจให้ได้อย่างน่าเชื่อถือ ตัวอย่างเช่น อย่าดำเนินการคืนเงินจนกว่า get_customer จะส่งข้อมูลตัวตนที่ผ่านการยืนยันแล้วกลับมา

ฮุกตรวจสอบข้อเท็จจริงในสถานะของคุณเอง ไม่ใช่คำกล่าวอ้างของโมเดลว่า "ยืนยันแล้ว" นี่คือความแตกต่างระหว่างหลักประกันที่แน่นอนกับคำสั่งที่หวังว่าจะทำตาม

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)

ส่งข้อมูลการบล็อกกลับไปยังโมเดล

การบล็อกเป็นเพียงครึ่งหนึ่งของงาน ฮุกที่กลืนการดำเนินการไปโดยไม่แจ้งจะทำให้โมเดลสับสนและทำให้ลูปหยุดชะงัก — นี่คือ การปกปิดโดยไม่แจ้ง ซึ่งเป็นรูปแบบการออกแบบที่ควรหลีกเลี่ยง

ให้ส่งการบล็อกกลับไปเป็น ผลลัพธ์จากเครื่องมือ ที่โมเดลอ่านและดำเนินการต่อได้แทน ข้อความการบล็อกที่ดีควรระบุเหตุผลและขั้นตอนถัดไปที่ถูกต้อง (ในที่นี้คือ escalate_to_human) เพื่อให้ผู้ช่วยกู้คืนการทำงานได้อย่างราบรื่นภายในลูปเดิม

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}

ฮุกกับการจำกัดจำนวนรอบ

อย่าสับสนระหว่างฮุกบังคับใช้กับ ตาข่ายนิรภัย ของลูป การจำกัดจำนวนรอบจะหยุดลูปที่ทำงานไม่สิ้นสุด แต่เป็นเพียงกลไกสำรอง — ไม่ใช่กลไกควบคุมหลัก และไม่ใช่สิ่งทดแทนการบังคับใช้นโยบายโดยเด็ดขาด

ฮุกมีลักษณะตรงกันข้าม: เป็นหลักประกันที่แม่นยำและตั้งใจใช้กับการดำเนินการเฉพาะอย่าง โมเดลยังคงเป็นผู้ตัดสินใจ ส่วนฮุกสงวนการใช้ โค้ดที่บังคับเด็ดขาดไว้เฉพาะหลักประกัน ที่สำคัญอย่างแท้จริง

ควรเลือกใช้ฮุกเมื่อใด

กฎการตัดสินใจสำหรับข้อสอบและระบบจริง:

ใช้ฮุก เมื่อความล้มเหลวมีความสำคัญด้านการเงิน กฎหมาย หรือความปลอดภัย หรือเมื่อต้องการเงื่อนไขก่อนดำเนินการหรือเกณฑ์ที่แน่นอน (คืนเงิน > $500 ต้องใช้มนุษย์อนุมัติ ต้องยืนยัน ID ก่อนจ่ายเงิน)
ใช้คำสั่ง สำหรับคำแนะนำที่ยืดหยุ่น น้ำเสียง และพฤติกรรมประมาณ 90% ที่การพลาดเป็นครั้งคราวยังยอมรับได้

ฮุก = แน่นอน คำสั่ง = อาศัยความน่าจะเป็น เลือกเครื่องมือให้เหมาะกับต้นทุนของความผิดพลาด

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ผู้ช่วยฝ่ายสนับสนุนมีเครื่องมือ process_refund นโยบายบริษัทกำหนดว่าการคืนเงินเกิน $500 ต้องได้รับอนุมัติจากมนุษย์ การคืนเงินส่วนใหญ่มีจำนวนน้อยและดำเนินการโดยอัตโนมัติ วิธีบังคับใช้ตามหลักสถาปัตยกรรมที่ถูกต้องคืออะไร

ตอบคำถามในบทเรียนแบบโต้ตอบ

สรุปทบทวน

ประเด็นสำคัญ:

PostToolUse ดักผลลัพธ์จากเครื่องมือก่อนที่โมเดลจะเห็น — ตัดทอนผลลัพธ์ที่มีรายละเอียดมากเกินไป ปรับความล้มเหลวทั่วไปให้อยู่ในรูปข้อผิดพลาดที่มีโครงสร้าง และแยกความล้มเหลวด้านการเข้าถึงออกจากผลลัพธ์ว่างที่ถูกต้อง
ฮุกการเรียกขาออก บล็อกการดำเนินการที่ละเมิดนโยบาย (คืนเงิน > $500) และบังคับใช้เงื่อนไขก่อนดำเนินการ (ยืนยัน ID ก่อนจ่ายเงิน)
ฮุก = แน่นอน 100%; คำสั่ง = อาศัยความน่าจะเป็นประมาณ 90% ใช้ฮุกเมื่อความล้มเหลวมีความสำคัญด้านการเงิน กฎหมาย หรือความปลอดภัย
ส่งการบล็อกกลับไปเป็นผลลัพธ์ที่มีโครงสร้างเสมอ — อย่าปกปิดโดยไม่แจ้ง การจำกัดจำนวนรอบเป็นตาข่ายนิรภัย ไม่ใช่กลไกบังคับใช้

เริ่มต้นได้ฟรี

เรียนรู้ Python ด้วย AI tutor — ฟรี

เขียนและเรียกใช้โค้ดจริงในเบราว์เซอร์ของคุณ รับความช่วยเหลือทันทีจาก AI tutor 24/7 และเรียนรู้ต่อจากที่คุณหยุดบนเว็บหรือในแอป

คอร์ส: 26
บทเรียน: 104

เริ่มเรียนฟรี ดูหลักสูตรเต็ม

คำถามที่พบบ่อย

บทเรียน “PostToolUse และฮุกสำหรับการเรียกออก” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “PostToolUse และฮุกสำหรับการเรียกออก” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Claude Architect ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Claude Architect มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “PostToolUse และฮุกสำหรับการเรียกออก”

ดักรับผลลัพธ์จากเครื่องมือและบล็อกการกระทำที่ละเมิดนโยบาย คุณปฏิบัติ Claude Architect ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Claude Architect หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Claude Architect บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 1 จากทั้งหมด 4 บทเรียน

บทเรียน “PostToolUse และฮุกสำหรับการเรียกออก” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Claude Architect นี้ได้ไหม

ได้ บทเรียน Claude Architect ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

PostToolUse และฮุกสำหรับการเรียกออก
การบังคับใช้แบบกำหนดแน่นอนเทียบกับพรอมต์
เงื่อนไขก่อนทำงานในโค้ด
โพรโทคอลส่งต่องานแบบมีโครงสร้าง

← กลับไปที่ Claude Architect