# Practical and Useful Patterns for OpenAI Agent SDK 🌍 Want to filter what goes into the model or gracefully handle errors without crashing? Input filters and error handlers give you fine-grained control over agent behavior at the edges. 📌 Title: Running agents – Hooks and customization / Error handlers 🔗 URL: 🧩 Overview `call_model_input_filter` is a hook that transforms model input just before it's sent — perfect for trimming history, masking secrets, or injecting dynamic system instructions. `error_handlers` lets you catch specific errors (tool failures, model refusals, max turns) and return app-specific fallback output instead of raising exceptions. Together, they enable production-grade resilient agents. 🛠 Usage Import `Agent`, `Runner`, and `ErrorHandlers` from `agents`. Define `trim_history(input_data)` to keep only the last 10 messages via `input_data.messages = input_data.messages[-10:]`, and `mask_secrets(input_data)` to replace secrets with `msg.content.replace(os.environ.get("API_KEY", ""), "***")`. Define `handle_refusal(ctx, error)` to return a domain-specific fallback on model refusal. Configure the agent with `Agent(name="chef", instructions="You are a recipe assistant.", call_model_input_filter=trim_history, error_handlers=ErrorHandlers(model_refusal=handle_refusal, max_turns=lambda ctx, err: FallbackOutput(message="Processing did not complete. Try shorter input.", include_in_history=False)))`. 🏗 Practical Patterns **History Trimming for Cost Control** Use `call_model_input_filter` to keep only the last N messages, reducing token consumption in long conversations. A practical pattern: always preserve the system prompt at the top while pruning older user messages. **Secret Masking** When tool outputs contain API keys or tokens, mask them before they reach the model via the input filter. This reduces the risk of the model memorizing or echoing sensitive information. **Dynamic System Instruction Injection** Inside the filter, inject context-aware system instructions based on user permissions or state. For example: "This customer is on the Premium plan" — letting the model tailor its responses dynamically. **Graceful max_turns Fallback** When a looping agent hits the turn limit, return a user-friendly message instead of an exception. Setting `include_in_history=False` keeps the fallback out of future turns, so retries start clean. **App-Specific Model Refusal Handling** Instead of catching `ModelRefusalError` and returning a generic error, return a structured fallback matching your domain model. A recipe app returns an empty Recipe with `refusal_reason`; a chat app suggests alternative topics. 💡 Use Cases 🔒 Prevent API keys and tokens from reaching the model 📏 Auto-trim long chat history to optimize token costs 🔄 Guide users to next actions when max_turns is reached 🛡 Return structured domain-specific fallbacks on model refusal ⚠️ Caveats - Over-pruning messages in `call_model_input_filter` causes the model to lose context and degrade response quality. Always preserve critical system prompts. - Ensure fallback outputs from `error_handlers` match the agent's `output_type`. Type mismatches cause runtime errors. - Fallback outputs with `include_in_history=False` won't be available in subsequent turns. Use this only for display-only information. - Exceptions thrown inside filters or handlers will halt the entire agent. Write defensive logic within these hooks. ✨ Combine input filters and error handlers to build agents that handle edge cases gracefully in production! #OpenAIAgentSDK# #AIAgent#