> ## 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.

# Failproof AI Observability Python SDK Agent Skill

> एक अनंतरित एजेंट से लेकर देखने योग्य इवेंट्स तक जाएं, आपके कोडिंग एजेंट के साथ इंस्ट्रूमेंटेशन बिंदु खोजते हैं, उन्हें लिखते हैं, और यह साबित करते हैं कि वे काम कर गए।

अपने कोडिंग एजेंट को बताएं *"इस एजेंट में Failproof AI Observability जोड़ें"* और इसे अपने लूप को पढ़ने, यह काम करने के लिए कि इंस्ट्रूमेंटेशन कहां होनी चाहिए, इसे लिखने, और इवेंट्स को सत्यापित करने दें कि काम समाप्त करने से पहले।

**Python SDK स्किल** (`agenteye-python-sdk`) एक *Agent Skill* है: निर्देशों की एक फोल्डर जो एक कोडिंग एजेंट जैसे Claude Code या Codex मांग पर लोड करता है जब कोई कार्य इससे मेल खाता है। यह एजेंट को [Python SDK](/hi/agenteye/python-sdk) का उपयोग करना सिखाता है — यह एक लाइब्रेरी नहीं है, और यह SDK कैसे काम करता है इसमें कुछ भी नहीं बदलता है।

## इंस्ट्रूमेंटेशन लिखना आसान है और चुपचाप गलत होना भी आसान है

SDK छोटा है: तेरह इवेंट मेथड, सभी केवल कीवर्ड। एक कोडिंग एजेंट [Python SDK](/hi/agenteye/python-sdk) संदर्भ को पढ़ सकता है और एक मिनट में प्रशंसनीय इंस्ट्रूमेंटेशन तैयार कर सकता है।

समस्या यह है कि यह SDK जब आप इसे गलत पाते हैं तो उठाता नहीं है, और गलत इंस्ट्रूमेंटेशन बिल्कुल सही इंस्ट्रूमेंटेशन जैसा दिखता है जब तक कोई डैशबोर्ड नहीं खोलता और इसे खाली नहीं पाता। असली समय खर्च करने वाली गलतियां सभी चुप्पियां हैं:

| गलती                           | आप क्या देखते हैं                                                          |
| ------------------------------ | -------------------------------------------------------------------------- |
| कोई `agent_start` नहीं         | हर इवेंट आता है। शून्य सत्र।                                               |
| पर्यावरण कभी सेट नहीं किया गया | सब कुछ काम करता है, `dev` के तहत दाखिल।                                    |
| `outcome="failure"`            | रन हरा दिखता है — केवल `failed`, `error`, `timeout`, `rejected` गिनते हैं। |
| एक टाइप की गई फील्ड का नाम     | स्वीकृत और एक नई फील्ड के रूप में संग्रहीत।                                |
| थ्रेड पूल से भेजे गए इवेंट्स   | चुपचाप हटाए गए।                                                            |

इनमें से कोई भी उठाता नहीं है। कोई भी परीक्षणों में दिखाई नहीं देता। हर एक स्किल में है, जो इसे पकड़ने वाली जांच के साथ एक अनुबंध के रूप में कहा गया है।

## यह क्या करता है, क्रम में

स्किल वही तीन चरण चलाती है जो एक सावधान इंजीनियर करेगा:

1. **योजना।** यह आपके एजेंट लूप को पढ़ता है और दो प्रश्न पूछता है जिनका जवाब केवल आप दे सकते हैं: एक रन क्या माना जाता है (आपका `session_id`), और पहचानने योग्य अभिनेता कौन हैं (आपका `agent_id`)। यह कोड लिखने से पहले इन पर सहमति प्राप्त करता है, क्योंकि उन्हें बाद में बदलने से आपका इतिहास विभाजित हो जाता है और रुझान टूट जाते हैं।
2. **लिखें।** यह पहचान को प्रति रन एक बार बांधता है बजाय इसे हर कॉल साइट के माध्यम से थ्रेड करने के, और यह एक सामग्री-सुरक्षित आकार चुनता है — एक विवरण जो महत्वपूर्ण है, क्योंकि स्पष्ट शॉर्टकट चुपचाप दो अतिव्यापी रन को एक सत्र में मिलाता है।
3. **सत्यापित करें।** यह आपके एजेंट को चलाता है और परिणामी इवेंट फाइलों को पढ़ता है, जांच करता है कि `agent_start` मौजूद है, पर्यावरण सही है, और एक रन ने एक सत्र बनाया है।

वह तीसरा चरण है जो लोग छोड़ देते हैं। SDK इवेंट्स को स्थानीय फाइलों में लिखता है, इसलिए एक पूर्ण एकीकरण एक लैपटॉप पर बिना सर्वर, API कुंजी, और नेटवर्क के सिद्ध किया जा सकता है — जो बिल्कुल वही है कि स्किल इसे करने पर जोर क्यों देती है।

## यह अन्य कौशलों से कैसे संबंधित है

तीन कौशल, एक स्वच्छ विभाजन:

| स्किल                                               | इसे तब पहुंचाएं जब                                                                                        | यह क्या स्पर्श करता है                                  |
| --------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | ------------------------------------------------------- |
| **Python SDK skill** (यह पृष्ठ)                     | आप चाहते हैं कि आपका एजेंट *टेलीमेट्री भेजे* — "अवलोकनीयता जोड़ें", "मेरा एजेंट क्यों दिखाई नहीं दे रहा?" | आपकी एजेंट के रेपो में कोड लिखता है। कुछ भी नहीं पढ़ता। |
| **[Evaluator skill](/hi/agenteye/evaluator-skill)** | आप रन को *स्कोर* करना चाहते हैं — "हमें क्या भी मापना चाहिए?"                                             | आपकी रेपो में कोड लिखता है; टेलीमेट्री पढ़ता है         |
| **[CLI skill](/hi/agenteye/cli-skill)**             | आप क्या *पढ़ना* चाहते हैं, या अपनी तैनाती संचालित करना चाहते हैं                                          | CLI को आपके रूप में चलाता है, परिवर्तन सहित             |

वे उस क्रम में हाथ बदलते हैं: यह स्किल इवेंट्स को बहने देती है, मूल्यांकनकर्ता उन्हें स्कोर करता है, CLI उन्हें वापस पढ़ता है। जब तक आपका एजेंट सत्र नहीं भेजता तब तक मूल्यांकन करने के लिए कुछ नहीं है और पढ़ने के लिए कुछ नहीं है, इसलिए यदि आप शुरुआत से शुरू कर रहे हैं, तो यहां से शुरू करें।

## पूर्वापेक्षाएं

1. **Python 3.10+** और वह एजेंट कोडबेस जिसे आप इंस्ट्रूमेंट करना चाहते हैं।
2. **SDK।** इसे ग्राहकों को एक निजी व्हील के रूप में वितरित किया जाता है न कि सार्वजनिक इंडेक्स से — आपकी ऑनबोर्डिंग इसे कैसे प्राप्त करें और इंस्टॉल करें कवर करती है। स्किल इंस्टॉल पथ जानती है और यदि यह इसे नहीं पा सकती तो आपसे पूछेगी न कि अनुमान लगाएगी।
3. **कुछ भी नहीं।** कोई डैशबोर्ड लॉगिन नहीं, कोई API कुंजी नहीं, कोई नेटवर्क नहीं। स्किल उन इवेंट फाइलों के विरुद्ध सत्यापन करती है जो SDK लिखती हैं, इसलिए यह समाप्त कर सकती है और अपने काम को ऑफलाइन साबित कर सकती है।

## इसे कहां से प्राप्त करें

स्किल सार्वजनिक [`FailproofAI/skills`](https://github.com/FailproofAI/skills) संग्रह में रहती है:

```bash theme={null}
npx skills add FailproofAI/skills --skill agenteye-python-sdk -a claude-code
```

इसे हर परियोजना के लिए केवल वर्तमान के बजाय इंस्टॉल करने के लिए `-g` जोड़ें, और `--copy` यदि आपका वातावरण सिम्लिंक का पालन नहीं करता है। Codex के लिए, `-a codex` पास करें।

## इसे हाथ से इंस्टॉल करना

Agent Skills `SKILL.md` प्लस संदर्भ वाली फोल्डर हैं। यदि आप इंस्टॉलर का उपयोग नहीं करना चाहते:

* **Claude Code**: `agenteye-python-sdk/` फोल्डर को `~/.claude/skills/` (हर परियोजना) या `<your-repo>/.claude/skills/` (केवल उस रेपो) में कॉपी करें। Claude Code इसे स्वचालित रूप से खोजता है — `/skills` सूची देखें, या बस ऐसा कुछ पूछें जो इससे मेल खाता है।
* **Codex**: Codex समान `SKILL.md` पढ़ता है। बंडल किया गया `agents/openai.yaml` `allow_implicit_invocation: true` सेट करता है, इसलिए यह स्वचालित रूप से चयनित है जब कोई कार्य मेल खाता है; अन्यथा इसे `$agenteye-python-sdk` के रूप में लागू करें।

अपने एजेंट को **उस रेपो में चलाएं जो कोड रखती है जिसे आप इंस्ट्रूमेंट करना चाहते हैं** — स्किल कुछ भी प्रस्तावित करने से पहले आपके एजेंट लूप को पढ़ता है।

## एक सत्र कैसा दिखता है

```text theme={null}
आप   ▸ इस एजेंट में Failproof AI Observability जोड़ें।

एजेंट ▸ आपका लूप पढ़ा — tools.py में एक टूल डिस्पैचर, llm.py में एक Anthropic
        रैपर। कोई भी कोड लिखने से पहले दो प्रश्न।

        एक रन क्या माना जाता है? आप अनुरोधों को समवर्ती रूप से संभालते हैं, इसलिए मैं
        अनुरोध आईडी का उपयोग करूंगा जो आपके पास पहले से ctx.request_id में है — फिर यहां
        एक सत्र और आपके लॉग में एक अनुरोध एक ही स्ट्रिंग हैं।

        और अभिनेता कौन हैं? मुझे एक प्लानर पथ और एक शोधकर्ता पथ दिख रहा है।
        उन्हें अलग से लेबल करें, या यह आपके लिए एक एजेंट है?

आप   ▸ अनुरोध आईडी सही है। वे एक एजेंट हैं, इसे "assistant" कहते हैं।

एजेंट ▸ हो गया। डिस्पैचर और LLM क्लाइंट को लपेटा; agent_start और
        agent_end handle_request को ब्रैकेट करते हैं, त्रुटि पथ सहित। एक
        संदर्भ-स्थानीय पहचान के लिए उपयोग किया — आपका डिस्पैचर थ्रेड पूल में उपकरण चलाता है, और
        सरल दृष्टिकोण समवर्ती रन को एक सत्र में शिकायत किए बिना मिलाता।

        एक वास्तविक रन के विरुद्ध सत्यापित: 4 फाइलों में 11 इवेंट्स —
        agent_start, model_request/response, tool_use/tool_result x3,
        agent_end (outcome=success)। environment=production, प्रति अनुरोध एक सत्र,
        जोड़े गए अवधि।

        एक चीज मैंने नहीं की: आपके batch.py में वर्कर पूल सीधे निष्पादक को
        सबमिट करता है, इसलिए वहां के इवेंट्स को हटाया जाएगा। क्या आप चाहते हैं कि मैं
        उन्हें भी ठीक करूं?
```

ध्यान देने योग्य पैटर्न: यह कोड पढ़ने से पहले पढ़ता है, केवल उन प्रश्नों पूछता है जिनका उत्तर आप दे सकते हैं, एक आईडी का पुन: उपयोग करता है जो आपके पास पहले से है, सामग्री-सुरक्षित आकार चुनता है *क्योंकि* यह एक थ्रेड पूल देखता है, और सफलता घोषित करने के बजाय **वास्तविक इवेंट्स पढ़कर** सत्यापन करता है — फिर एक जगह को फ्लैग करता है जहां यह जानता है कि चुपचाप विफल हो जाएगा।

## आप इससे क्या पूछ सकते हैं

* *"मेरा एजेंट डैशबोर्ड पर क्यों दिखाई नहीं दे रहा?"* → सीढ़ी चलाता है: क्या इवेंट्स लिखे जा रहे हैं, क्या `agent_start` है, पर्यावरण सही है, क्या संग्राहक एक ही जगह पढ़ रहा है।
* *"सब कुछ dev के तहत आता है।"* → पर्यावरण कभी सेट नहीं किया गया था, या बाद की कॉल द्वारा रीसेट किया गया था।
* *"टोकन ट्रैकिंग जोड़ें।"* → आपके LLM रैपर को ढूंढता है और मॉडल, स्टॉप कारण, और उपयोग रिकॉर्ड करता है।
* *"उप-एजेंटों को भी इंस्ट्रूमेंट करें।"* → एक सत्र, विशिष्ट एजेंट लेबल, उनके माता-पिता के तहत नेस्टेड।
* *"इंस्ट्रूमेंटेशन के लिए परीक्षण लिखें।"* → SDK को एक अस्थायी निर्देशिका पर इंगित करता है और इवेंट्स पर कि यह लिखती है पर कथन।

## क्या देखने के लिए

**इसे सत्यापन करने दें।** वह चरण जो इस स्किल को उपयोग के लायक बनाता है आखिरी है — अपने एजेंट को चलाना और इवेंट्स को वापस पढ़ना। एक एजेंट जो इंस्ट्रूमेंटेशन लिखता है और रुकता है वह आसान आधा किया है, और जो आधा चुपचाप विफल हो सकता है वह दूसरा है।

**कोड से पहले नामों पर सहमत हों।** `session_id` और `agent_id` हर सतह जो समूह करती है उसके अक्ष हैं। उन्हें बाद में तोड़ने से इतिहास विभाजित होता है: पुरानी रन पुरानी लेबल रखते हैं और आपके रुझान टूट जाते हैं। स्किल पूछेगी; उत्तर एक मिनट की सोच के लायक है।

**यदि आपका एजेंट SDK को सार्वजनिक इंडेक्स से इंस्टॉल करने का प्रस्ताव देता है, तो स्किल लोड नहीं हुई।** SDK निजी तौर पर वितरित किया जाता है। यह प्रस्ताव एक विश्वसनीय संकेत है कि आपका कोडिंग एजेंट अनुमान लगा रहा है न कि स्किल का पालन कर रहा है — इसे वहां रोकें और जांचें कि स्किल स्थापित है।

उसके बाहर इसका विस्फोट त्रिज्या छोटी है: यह आपकी कार्य निर्देशिका में कोड लिखता है और इवेंट फाइलें जहां आप इसे बताते हैं। यह आपकी तैनाती से कुछ भी नहीं पढ़ता है और इसके बारे में कुछ भी नहीं बदलता है।

## अगले कदम

* **[Python SDK](/hi/agenteye/python-sdk)**: पूर्ण इवेंट संदर्भ — हर इवेंट प्रकार और फील्ड — जो यह स्किल स्वचालित करता है उसके पीछे।
* **[Sessions](/hi/agenteye/sessions)**: आपका इंस्ट्रूमेंटेशन एक बार इवेंट्स आते हैं तो क्या बनाता है।
* **[Evaluator Agent Skill](/hi/agenteye/evaluator-skill)**: अगला कदम एक बार रन आ रहे हों — उन्हें स्कोर करना।
* **[CLI Agent Skill](/hi/agenteye/cli-skill)**: आपकी टेलीमेट्री को वापस पढ़ना।