> ## Documentation Index > Fetch the complete documentation index at: https://docs.befailproof.ai/llms.txt > Use this file to discover all available pages before exploring further. # कस्टम नीतियां > अपने एजेंटों के लिए विशिष्ट विफलताओं के लिए JavaScript या TypeScript नीतियां तैयार करें, परीक्षण करें और तैनात करें। कस्टम नीतियां आपके ट्रेस या ऑडिट से विफलता पैटर्न को एक निर्णय में बदल देती हैं जो एजेंट के काम करते समय चलती है। एक नीति किसी क्रिया को अनुमति दे सकती है, एजेंट को मार्गदर्शन दे सकती है, या किसी अन्य घटना का कारण बनने से पहले क्रिया को अस्वीकार कर सकती है। कस्टम नीति का उपयोग करें जब व्यवहार आपके टूल्स, पथों, कमांड, वातावरण या ऑपरेटिंग नियमों पर निर्भर हो। पहले [बिल्ट-इन नीति कैटलॉग](/hi/policies/builtin-catalog) देखें ताकि आप किसी मौजूदा नियंत्रण को पुनः न बनाएं। ## कस्टम नीति तैयार करें 1. **Admin → policy editor** पर जाएं, **New policy** चुनें और उस विफलता का वर्णन करें जिसे आप रोकना चाहते हैं। 2. नीति स्रोत जोड़ें, फिर संपादक में अपेक्षित मेलों और सुरक्षित गैर-मेलों का परीक्षण करें। हर सत्यापन त्रुटि को हल करें। 3. ड्राफ्ट सहेजें और एक अपरिवर्तनीय संस्करण बनाने के लिए **Publish version** चुनें। 4. **Admin → enforcement** पर जाएं, संस्करण को **observe** मोड में एक परीक्षण मशीन पर तैनात करें, और **Observe → policy** के तहत इसके निर्णयों को सत्यापित करने से पहले लागू करें। कस्टम नीति को तैयार करने और प्रकाशित करने के लिए उपयोग किया जाने वाला नीति संपादक। 1. `.failproofai/policies/checkout-policies.ts` बनाएं। फ़ाइल नाम को `policies.js`, `policies.mjs` या `policies.ts` में समाप्त होना चाहिए। 2. `customPolicies.add()` के साथ एक या अधिक नीतियां पंजीकृत करें। 3. `failproofai policies --install --custom ./.failproofai/policies/checkout-policies.ts --scope project` के साथ फ़ाइल को सत्यापित करें और इंस्टॉल करें। 4. एक मेलिंग क्रिया और एक सुरक्षित क्रिया ट्रिगर करें। `failproofai policies` चलाएं, फिर **Observe → policy** के तहत जिम्मेदार निर्णयों का निरीक्षण करें। ## एक संकीर्ण नियम से शुरुआत करें यह नीति विनाशकारी Kubernetes कमांड को केवल तब ब्लॉक करती है जब कमांड प्रोडक्शन को लक्षित करता है। उस सटीक विफलता मोड के बाहर की हर चीज `allow()` लौटाती है। ```ts theme={null} import { customPolicies, allow, deny } from "failproofai"; const DESTRUCTIVE_KUBECTL = /\bkubectl\s+(delete|replace)\b/i; const PRODUCTION_TARGET = /(?:--context|--namespace|-n)\s+(prod|production)\b/i; customPolicies.add({ name: "block-destructive-production-kubectl", description: "Block destructive Kubernetes commands against production", match: { events: ["PreToolUse"] }, fn: async ({ toolName, toolInput }) => { if (toolName !== "Bash") return allow(); const command = String(toolInput?.command ?? ""); if (!DESTRUCTIVE_KUBECTL.test(command)) return allow(); if (!PRODUCTION_TARGET.test(command)) return allow(); return deny( "Destructive production Kubernetes commands require the approved deployment workflow.", ); }, }); ``` अच्छी नीतियां इतनी संकीर्ण होती हैं कि उन्हें एक वाक्य में समझाया जा सके। देखने योग्य क्रिया से मेल खाएं—न कि उस इरादे से जो आप चाहते थे कि एजेंट के पास हो—और जैसे ही नियम लागू न हो, `allow()` लौटाएं। ## एक निर्णय चुनें | हेल्पर | परिणाम | इसका उपयोग करें जब | | ------------------ | ------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- | | `allow(reason?)` | ऑपरेशन जारी रहता है। | नीति लागू नहीं होती है या क्रिया सुरक्षित है। | | `instruct(reason)` | ऑपरेशन जहां हार्नेस इसका समर्थन करता है वहां मार्गदर्शन के साथ जारी रहता है। | आप एजेंट को किसी बेहतर दृष्टिकोण की ओर निर्देशित करना चाहते हैं बिना किसी अपरिवर्तनीय को लागू किए। | | `deny(reason)` | ऑपरेशन को ब्लॉक किया जाता है जब इवेंट और हार्नेस ब्लॉक करने का समर्थन करते हैं। | क्रिया को आगे नहीं बढ़ना चाहिए। | एजेंट के लिए कारण लिखें जिसे पुनरुद्धार करना चाहिए। समझाएं कि क्या पहचाना गया था और इसे इसके बजाय क्या करना चाहिए। सुरक्षा सीमा के लिए `instruct()` का उपयोग न करें। मार्गदर्शन वितरण एजेंट हार्नेस द्वारा भिन्न होता है। जब क्रिया को रोका जाना चाहिए तो `deny()` का उपयोग करें। ## नीति ऑब्जेक्ट ```ts theme={null} customPolicies.add({ name: "policy-name", description: "What this policy prevents", match: { events: ["PreToolUse"] }, fn: async (ctx) => allow(), }); ``` | फ़ील्ड | आवश्यक | विवरण | | -------------- | ------ | --------------------------------------------------------------------------------------------------- | | `name` | हां | नीति के लिए स्थिर पहचानकर्ता। फ़ाइलों में नाम अनोखे रखें। | | `description` | नहीं | नीति सूचियों और निर्णयों में दिखाया गया मानव-पठनीय उद्देश्य। | | `match.events` | नहीं | इवेंट प्रकार जो नीति को लागू करते हैं। `match` को छोड़ने से यह हर उपलब्ध इवेंट के लिए लागू होता है। | | `fn` | हां | सिंक्रोनस या अतुल्यकालिक फ़ंक्शन जो `allow`, `instruct` या `deny` परिणाम लौटाता है। | `fn` के अंदर टूल्स को फ़िल्टर करें। `match.toolNames` सार्वजनिक कस्टम-नीति प्रकार का हिस्सा नहीं है। ## नीति संदर्भ हर नीति को एक `PolicyContext` प्राप्त होता है। | फ़ील्ड | प्रकार | इसमें क्या होता है | | ----------- | -------------------------------------- | ----------------------------------------------------------------------------------------------- | | `eventType` | `HookEventType` | वर्तमान में मूल्यांकन किए जा रहे सामान्यीकृत इवेंट। | | `toolName` | `string \| undefined` | `Bash`, `Read`, `Write` या `Edit` जैसा विहित टूल नाम। | | `toolInput` | `Record \| undefined` | वर्तमान टूल कॉल के लिए विहित इनपुट। | | `payload` | `Record` | संपूर्ण सामान्यीकृत इवेंट पेलोड। | | `session` | `SessionMetadata \| undefined` | जब उपलब्ध हो तो सत्र ID, कार्यशील निर्देशिका, ट्रांसक्रिप्ट पथ, अनुमति मोड और हार्नेस मेटाडेटा। | | `cli` | `string \| undefined` | एजेंट हार्नेस स्रोत, जैसे `claude`, `codex` या `cursor`। | | `params` | `Record` | बिल्ट-इन नीति पैरामीटर। कस्टम नीतियां वर्तमान में एक खाली ऑब्जेक्ट प्राप्त करती हैं। | हर वैकल्पिक मान को वास्तव में वैकल्पिक मानें। एजेंट संस्करण और इवेंट प्रकार सभी समान फ़ील्ड प्रदान नहीं करते। ### सामान्य टूल इनपुट Failproof AI सामान्य टूल्स को समर्थित हार्नेस में सामान्यीकृत करता है ताकि एक नीति आमतौर पर एक इनपुट आकार का उपयोग कर सके। | टूल | सामान्य फ़ील्ड | | ------- | --------------------------------------- | | `Bash` | `command` | | `Read` | `file_path` | | `Write` | `file_path`, `content` | | `Edit` | `file_path`, `old_string`, `new_string` | | `Grep` | `pattern`, `path` | रक्षात्मक जबरदस्ती का उपयोग करें क्योंकि टूल इनपुट मान `unknown` के रूप में टाइप किए जाते हैं: ```ts theme={null} const command = String(ctx.toolInput?.command ?? ""); const filePath = String(ctx.toolInput?.file_path ?? ""); ``` ## इवेंट चुनें | इवेंट | कब चलता है | विशिष्ट उपयोग | | ----------------------------- | -------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | | `PreToolUse` | टूल निष्पादित होने से पहले। | कमांड, लेखन, पठन और बाहरी क्रियाओं को ब्लॉक या मार्गदर्शन दें। | | `PostToolUse` | टूल वापस लौटने के बाद। | परिणामों का निरीक्षण करें उससे पहले कि वे एजेंट तक पहुंचें। एक deny पूरे परिणाम को ब्लॉक करता है; यह चयनित फ़ील्ड को संपादित नहीं करता। | | `PermissionRequest` | जब एजेंट अनुमति का अनुरोध करता है। | संगठन-विशिष्ट अनुमति नियम लागू करें। | | `UserPromptSubmit` | सबमिट किए गए प्रॉम्प्ट के जारी रहने से पहले। | निषिद्ध निर्देशों को अस्वीकार करें या वर्कफ़्लो मार्गदर्शन जोड़ें। | | `Stop` | जब एजेंट समाप्त करने का प्रयास करता है। | एक पहुंचने योग्य पूर्णता स्थिति की आवश्यकता है, जैसे स्थानीय सत्यापन चरण। | | `SubagentStop` | जब एक सबएजेंट समाप्त करने का प्रयास करता है। | मूल को वापस लौटने से पहले प्रत्यायोजित कार्य को गेट करें। | | `SessionStart` / `SessionEnd` | सत्र सीमाओं पर। | सत्र-स्तर की स्थिति रिकॉर्ड या जांच करें। | इवेंट उपलब्धता और ब्लॉकिंग व्यवहार एजेंट हार्नेस पर निर्भर करते हैं। मिश्रित फ़्लीट में एक इवेंट पर निर्भर होने से पहले [एजेंट हार्नेस](/hi/reference/harnesses) देखें। `SessionStart`, `SessionEnd`, `UserPromptSubmit`, `PreToolUse`, `PermissionRequest`, `PermissionDenied`, `PostToolUse`, `PostToolUseFailure`, `Notification`, `SubagentStart`, `SubagentStop`, `TaskCreated`, `TaskCompleted`, `Stop`, `StopFailure`, `TeammateIdle`, `InstructionsLoaded`, `ConfigChange`, `CwdChanged`, `FileChanged`, `WorktreeCreate`, `WorktreeRemove`, `PreCompact`, `PostCompact`, `Elicitation`, `ElicitationResult`, `UserPromptExpansion`, `PostToolBatch` और `Setup`। ## सामान्य नीति पैटर्न तैयार करें ### सुरक्षित पथों में लेखन को ब्लॉक करें ```ts theme={null} import { customPolicies, allow, deny } from "failproofai"; customPolicies.add({ name: "block-generated-file-edits", description: "Require generated files to be changed through their generator", match: { events: ["PreToolUse"] }, fn: async (ctx) => { if (!["Write", "Edit"].includes(ctx.toolName ?? "")) return allow(); const filePath = String(ctx.toolInput?.file_path ?? ""); if (!/(^|\/)(dist|generated)\//.test(filePath)) return allow(); return deny("Edit the source and run the generator instead of changing generated output."); }, }); ``` ### गैर-ब्लॉकिंग मार्गदर्शन दें ```ts theme={null} import { customPolicies, allow, instruct } from "failproofai"; customPolicies.add({ name: "prefer-reviewed-deploy-command", description: "Guide agents toward the reviewed deployment wrapper", match: { events: ["PreToolUse"] }, fn: async (ctx) => { if (ctx.toolName !== "Bash") return allow(); const command = String(ctx.toolInput?.command ?? ""); if (!/^kubectl\s+apply\b/.test(command.trim())) return allow(); return instruct("Use ./scripts/deploy-reviewed instead of invoking kubectl directly."); }, }); ``` ### सत्र पूर्णता को गेट करें ```ts theme={null} import { execFileSync } from "node:child_process"; import { customPolicies, allow, deny } from "failproofai"; customPolicies.add({ name: "require-clean-typecheck", description: "Require the project typecheck to pass before the agent finishes", match: { events: ["Stop"] }, fn: async (ctx) => { const cwd = ctx.session?.cwd; if (!cwd) return allow(); try { execFileSync("bunx", ["tsc", "--noEmit"], { cwd, stdio: "ignore", timeout: 8_000, }); return allow(); } catch { return deny("Fix the typecheck errors before finishing the task."); } }, }); ``` एक अस्वीकृत `Stop` इवेंट एजेंट को पुनः प्रयास कर सकता है। केवल एक ऐसी स्थिति पर गेट करें जिसे एजेंट वर्तमान वातावरण में पूरा कर सकता है, और हर सबप्रोसेस या नेटवर्क कॉल को बाध्य करें। ## नीति फ़ाइलें लोड करें ### सम्मेलन फ़ाइलें सम्मेलन फ़ाइलें स्वचालित रूप से लोड होती हैं: ```text theme={null} /.failproofai/policies/security-policies.ts ~/.failproofai/policies/personal-policies.mjs ``` * प्रोजेक्ट और उपयोगकर्ता नीति निर्देशिकाएं दोनों लोड की जाती हैं। * फ़ाइलें प्रत्येक निर्देशिका के भीतर वर्णानुक्रम में लोड होती हैं। * एक फ़ाइल को `policies.js`, `policies.mjs` या `policies.ts` में समाप्त होना चाहिए। * एक फ़ाइल में कई `customPolicies.add()` कॉल समर्थित हैं। * स्थानीय मॉड्यूल से सापेक्ष आयात समर्थित हैं। * प्रोजेक्ट नीतियों को प्रतिबद्ध किया जा सकता है ताकि समान नियम रिपॉजिटरी का पालन करें। ### स्पष्ट फ़ाइलें स्पष्ट पथों का उपयोग करें जब सत्यापन या कॉन्फ़िगरेशन को प्रविष्टि फ़ाइल का नाम सीधे देना चाहिए: ```bash theme={null} failproofai policies --install \ --custom ./security.policies.ts \ --custom ./workflow.policies.ts \ --scope project ``` स्पष्ट फ़ाइलें पहले लोड होती हैं, इसके बाद प्रोजेक्ट सम्मेलन फ़ाइलें और फिर उपयोगकर्ता सम्मेलन फ़ाइलें। दोनों पथों से खोजी गई एक फ़ाइल एक बार लोड की जाती है। ## सत्यापित करें और परीक्षण करें सत्यापन मॉड्यूल को उत्पादन लोडर के माध्यम से निष्पादित करता है और पुष्टि करता है कि यह कम से कम एक नीति पंजीकृत करता है। ```bash theme={null} failproofai policies --install \ --custom ./.failproofai/policies/checkout-policies.ts \ --scope project failproofai policies ``` सत्यापन लापता फ़ाइलें, सिंटैक्स त्रुटियां, अनसुलझे आयात, शीर्ष-स्तरीय अपवाद और मॉड्यूल-लोड टाइमआउट को पकड़ता है। यह साबित नहीं करता है कि आपका मेल तर्क सही है। कम से कम इन मामलों का परीक्षण करें: * एक क्रिया जो मेल खानी चाहिए और इच्छित नीति कारण उत्पादित करना चाहिए। * एक पास की क्रिया जो सुरक्षित होनी चाहिए और `allow()` लौटानी चाहिए। * लापता या गलत टूल फ़ील्ड। * वैकल्पिक कमांड सिंटैक्स, पथ, उद्धरण, केसिंग और व्हाइटस्पेस। * एक अनुपलब्ध सबप्रोसेस या नेटवर्क निर्भरता। परिणाम को **Observe → policy** के तहत आपकी कस्टम नीति को जिम्मेदार ठहराएं। एक अवरुद्ध परीक्षण पर्याप्त नहीं है यदि कोई अन्य बिल्ट-इन नीति ने निर्णय लिया। ## रनटाइम व्यवहार * बिल्ट-इन नीतियां कस्टम नीतियों से पहले मूल्यांकित होती हैं। * पहली `deny` आगे की नीति मूल्यांकन को रोक देती है। * कई `instruct` परिणामों को जोड़ा जा सकता है जब कोई नीति इवेंट को अस्वीकार नहीं करता। * एक नीति फ़ंक्शन के पास 10-सेकंड की निष्पादन समय सीमा होती है। * एक फेंकी गई अपवाद या टाइमआउट लॉग की जाती है और `allow()` के रूप में व्यवहार की जाती है। * एक सम्मेलन फ़ाइल जो लोड करने में विफल रहती है वह छोड़ दी जाती है; अन्य कस्टम फ़ाइलें और बिल्ट-इन नीतियां जारी रहती हैं। * शीर्ष-स्तरीय मॉड्यूल लोडिंग में भी 10-सेकंड की समय सीमा होती है। * क्लाउड ऑब्जर्व मोड नीति चलाता है लेकिन इसे लागू किए बिना एक गैर-allow निर्णय दर्ज करता है। नीति मॉड्यूल को नियतात्मक और तेज रखें। शीर्ष-स्तरीय नेटवर्क कॉल या सर्वर स्टार्टअप से बचें। `fn` के अंदर काम को बाध्य करें, निर्भरता विफलताओं को पकड़ें और जानबूझकर चुनें कि क्या वह विफलता ऑपरेशन को अनुमति देनी चाहिए या नहीं। ## API निर्यात | निर्यात | उद्देश्य | | ---------------------------- | -------------------------------------------------------------------- | | `customPolicies.add(policy)` | जब मॉड्यूल लोड हो तो कस्टम नीति पंजीकृत करें। | | `allow(reason?)` | ऑपरेशन की अनुमति दें। | | `instruct(reason)` | ऑपरेशन की अनुमति दें और जहां समर्थित हो वहां मार्गदर्शन प्रदान करें। | | `deny(reason)` | जहां समर्थित हो ऑपरेशन को ब्लॉक करें। | | `getCustomHooks()` | वर्तमान में मॉड्यूल रजिस्ट्री में पंजीकृत नीतियां लौटाएं। | | `clearCustomHooks()` | उस रजिस्ट्री को साफ करें, मुख्य रूप से परीक्षण और लोडर के लिए। | TypeScript `PolicyContext`, `PolicyResult`, `CustomHook`, `PolicyDecision` और `PolicyFunction` निर्यात करता है। एक संस्करण प्रकाशित करें, इसे observe मोड में तैनात करें, निर्णयों को सत्यापित करें और प्रवर्तन के लिए आगे बढ़ें।