---
title: "लंबे चलने वाले AI एजेंट: timeout, retry, checkpoint | BroadRouter"
description: "LLM एजेंट को घंटों चलाते रहें: हर कॉल पर timeout, अटकने का पता लगाने के लिए स्ट्रीमिंग, सुरक्षित retry, idempotent tool side effect और हर चरण के बाद checkpoint।"
url: https://broadrouter.com/hi/blog/long-running-agents-timeouts-retries/
lang: hi
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

यह पेज अंग्रेज़ी से AI की मदद से अनुवाद किया गया है। [अंग्रेज़ी मूल पढ़ें](https://broadrouter.com/blog/long-running-agents-timeouts-retries/) (2026-11-16 को अपडेट किया गया).

# लंबे चलने वाले एजेंट: टिकाऊ timeout, retry और checkpoint

BroadNet Inference टीम · 4 मिनट में पढ़ें · प्रकाशित 2026-11-14 · अपडेट किया गया 2026-11-16

हर मॉडल कॉल को फेंकने योग्य और एजेंट की स्थिति को टिकाऊ मानें। हर कॉल पर timeout लगाएँ, अटकने का पता लगाने के लिए स्ट्रीम करें, 429, 5xx और टूटी स्ट्रीम को सीमित backoff के साथ retry करें, और side effect वाले हर tool को idempotency key दें। हर चरण के बाद मैसेज लिस्ट सेव करें, ताकि क्रैश के बाद एजेंट शुरू से नहीं, आख़िरी checkpoint से चले।

## मुख्य बातें

-   OpenAI Python SDK डिफ़ॉल्ट रूप से 10 मिनट बाद timeout होता है और दो बार retry करता है। एजेंट के लिए दोनों को साफ़-साफ़ ख़ुद सेट करें।
-   जो स्ट्रीम data \[DONE\] से पहले ख़त्म हो जाए, वह अधूरा जवाब है। उसे retry करना एक नया inference है, जिसका उपयोग के अनुसार भुगतान में फिर से बिल बनता है।
-   मॉडल कॉल को retry करना सुरक्षित है। tool के side effect नहीं, जब तक उनके साथ idempotency key न हो।
-   हर पूरे हुए चरण के बाद checkpoint करें: मैसेज लिस्ट, चरण संख्या और पूरे हो चुके side effect के ID।
-   प्लान सेशन पर retry का कोई अतिरिक्त ख़र्च नहीं, लेकिन चलते समय वे एकमात्र अनुरोध स्लॉट घेरते हैं।

**इस पेज पर**

1.  एजेंट घंटों चले तो क्या टूटता है?
2.  1\. एक कॉल को कितना समय लेने दें?
3.  2\. लंबे चलने वाले एजेंट में स्ट्रीम क्यों करें?
4.  3\. क्या retry करना चाहिए?
5.  4\. tool calls को idempotent कैसे बनाएँ?
6.  5\. एजेंट का checkpoint कैसे बनाएँ?
7.  रात भर के रन से पहले की चेकलिस्ट
8.  BroadNet Inference कहाँ फ़िट होता है

पाँच मिनट चलने वाला एजेंट विफलता को नज़रअंदाज़ कर सकता है। पाँच घंटे चलने वाला एजेंट timeout, 429, टूटी स्ट्रीम और शायद एक restart, सब देखेगा। लंबे चलने वाले एजेंट पर ज़्यादातर गाइड कोई workflow engine बेचती हैं। हो सकता है आपको उसकी ज़रूरत न हो। यह पोस्ट उन पाँच आदतों के बारे में है जो एक सादे एजेंट लूप को घंटों ज़िंदा रखती हैं, OpenAI Python SDK के कोड के साथ।

## एजेंट घंटों चले तो क्या टूटता है?

| विफलता | कैसी दिखती है | कौन-सी आदत इसे संभालती है |
| --- | --- | --- |
| अटकी या धीमी कॉल | मिनटों तक कोई जवाब नहीं | हर कॉल पर timeout, स्ट्रीमिंग |
| रेट लिमिट या ओवरलोड | 429, 5xx | backoff के साथ सीमित retry |
| टूटी स्ट्रीम | `[DONE]` से पहले कनेक्शन ख़त्म | अधूरा मानें, कॉल retry करें |
| दोहराया गया side effect | retry के बाद tool दो बार चलता है | Idempotency key |
| प्रोसेस क्रैश या डिप्लॉय | एजेंट चरण 1 से दोबारा शुरू होता है | हर चरण पर checkpoint |

## 1\. एक कॉल को कितना समय लेने दें?

OpenAI Python SDK का README कहता है कि अनुरोध डिफ़ॉल्ट रूप से 10 मिनट बाद timeout होते हैं और कुछ एरर दो बार retry किए जाते हैं। एजेंट के लिए दोनों ख़ुद सेट करें, ताकि व्यवहार आपकी जानकारी के बिना न बदले:

```python
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"],
                timeout=300, max_retries=4)
```

timeout डेटा से चुनें। एक दिन तक हर कॉल की अवधि लॉग करें; timeout को सबसे धीमी सफल कॉल से काफ़ी ऊपर रखें। बड़े प्रॉम्प्ट शुरू होने में ज़्यादा समय लेते हैं, और [reasoning मॉडल](https://broadrouter.com/hi/glossary/reasoning-tokens/) लिखने से पहले सोचते हैं। लगभग 100 टोकन प्रति सेकंड पर 8,000 आउटपुट टोकन अकेले ही एक मिनट से ज़्यादा लेते हैं। हर **टास्क** के लिए एक अलग wall-clock बजट जोड़ें, ताकि चलता रहने वाला लूप पूरी रात न चले।

## 2\. लंबे चलने वाले एजेंट में स्ट्रीम क्यों करें?

[स्ट्रीमिंग](https://broadrouter.com/hi/glossary/streaming/) मॉडल के काम करते समय आपको संकेत देती है। इसके बिना धीमी कॉल और मरा हुआ कनेक्शन timeout होने तक एक जैसे दिखते हैं। इसके साथ आप chunks आते देख सकते हैं और आख़िरी chunk में टोकन usage भी पाते हैं।

BroadNet के स्ट्रीमिंग नियम: शाब्दिक `data: [DONE]` पंक्ति तक पढ़ें। अगर कनेक्शन उससे पहले बंद हो जाए, तो जवाब अधूरा है। `X-Request-ID` रिकॉर्ड करें, फिर तय करें कि नया अनुरोध करना है या नहीं। [पूरी स्ट्रीमिंग गाइड](https://broadrouter.com/hi/guides/streaming-chat-completions/)।

```python
def call_streaming(messages, tools=None):
    parts, done = [], False
    stream = client.chat.completions.create(
        model="broadnet/glm-5.3", messages=messages, tools=tools, stream=True,
        stream_options={"include_usage": True}, max_tokens=8000)
    for chunk in stream:
        if chunk.choices and chunk.choices[0].finish_reason:
            done = True
        if chunk.choices and chunk.choices[0].delta.content:
            parts.append(chunk.choices[0].delta.content)
    if not done:
        raise IncompleteStream()   # retry the whole call
    return "".join(parts)
```

यह स्केच सिर्फ़ टेक्स्ट इकट्ठा करता है। अगर आप tool calls स्ट्रीम करते हैं, तो `delta.tool_calls` को भी index के हिसाब से जोड़ें।

## 3\. क्या retry करना चाहिए?

SDK पहले से कनेक्शन एरर, 408, 409, 429 और 5xx retry करता है। उसके ऊपर अपना retry सिर्फ़ उसके लिए लगाएँ जो SDK नहीं देख सकता, जैसे अधूरी स्ट्रीम:

1.  **Retry करें:** कनेक्शन एरर, 429, 5xx, अधूरी स्ट्रीम। jitter और ऊपरी सीमा के साथ [exponential backoff](https://broadrouter.com/hi/glossary/exponential-backoff/) इस्तेमाल करें, उदाहरण के लिए 4 प्रयास।
2.  **Retry नहीं, ठीक करें:** 400, 401, 402, 403, 413, 422। ये हर बार एक ही तरह फ़ेल होते हैं। [एरर कोड और कब retry करें](https://broadrouter.com/hi/guides/errors-and-retries/) देखें।
3.  **retry का बजट हर टास्क पर रखें**, सिर्फ़ हर कॉल पर नहीं। दस चरण, हर एक चार बार retry, यानी चालीस अतिरिक्त कॉल।
4.  **retry ख़त्म होने पर failover करें।** अगर रन को प्रोवाइडर के आउटेज में भी बचना है, तो कनेक्शन एरर, 5xx और रेट-लिमिट वाले 429 को दूसरे प्रोवाइडर पर भेजें। [LLM API failover](https://broadrouter.com/hi/blog/llm-api-failover-fallback/) में क्लाइंट कोड और circuit breaker है।

उपयोग के अनुसार भुगतान में हर retry एक नया inference है, जिसका फिर से बिल बनता है। उपयोग के अनुसार भुगतान वाली key प्रति मिनट 30 अनुरोध और एक साथ 4 अनुरोध की अनुमति देती है, इसलिए retry की बौछार जल्दी ही [रेट लिमिट](https://broadrouter.com/hi/glossary/rate-limit/) से टकराती है; [रेट लिमिट कैलकुलेटर](https://broadrouter.com/tools/llm-rate-limit-calculator/) दिखाता है कि आपके एजेंट के पास कितनी गुंजाइश है। backoff का विस्तार [429 संभालने वाली पोस्ट](https://broadrouter.com/hi/blog/handle-llm-api-429-rate-limits/) में है। [अनलिमिटेड प्लान](https://broadrouter.com/hi/guides/unlimited-llm-api-sessions/) पर retry का कोई अतिरिक्त ख़र्च नहीं, लेकिन चलते समय वे सेशन का एकमात्र अनुरोध स्लॉट घेरते हैं।

## 4\. tool calls को idempotent कैसे बनाएँ?

मॉडल कॉल का कोई side effect नहीं होता। tool कॉल का हो सकता है। अगर `send_invoice` चलने के बाद पर चरण सेव होने से पहले एजेंट क्रैश हो जाए, तो दोबारा शुरू हुआ एजेंट उसे फिर भेज देगा।

side effect वाली हर कॉल को टास्क और चरण से बनी एक [idempotency key](https://broadrouter.com/hi/glossary/idempotency-key/) दें, एक्शन से पहले उसे जाँचें, और अगर वह पहले से रिकॉर्ड है तो कॉल छोड़ दें:

```python
def run_side_effect(task_id, step, call, store):
    key = f"{task_id}:{step}:{call.id}"
    if store.done(key):
        return store.result(key)       # already ran: return the saved result
    result = execute(call)             # pass key to the API if it supports one
    store.save(key, result)
    return result
```

कई पेमेंट और मैसेजिंग API idempotency key हेडर स्वीकार करते हैं। जहाँ स्वीकार करें, अपनी key आगे भेज दें।

## 5\. एजेंट का checkpoint कैसे बनाएँ?

हर पूरे हुए चरण के बाद सेव करें: मैसेज लिस्ट, चरण संख्या और side effect की keys। शुरू होते समय, अगर आख़िरी checkpoint मौजूद हो, तो उसे लोड करें।

```python
def save_checkpoint(path, step, messages):
    tmp = path + ".tmp"
    with open(tmp, "w") as f:
        json.dump({"step": step, "messages": messages}, f)
    os.replace(tmp, path)   # atomic on the same filesystem
```

temp फ़ाइल में लिखकर rename करने का मतलब है कि लिखते-लिखते क्रैश होने पर भी कभी आधा checkpoint नहीं बचता। बहुत लंबे सेशन के लिए एक **सारांश** का भी checkpoint बनाएँ: पुराने turns को छोटे सारांश से बदल दें, ताकि दोबारा शुरू हुआ एजेंट बहुत बड़ा इतिहास फिर से लोड न करे। इससे आप [कॉन्टेक्स्ट विंडो](https://broadrouter.com/hi/glossary/context-window/) के भीतर रहते हैं, [DeepSeek V4.1 Flash](https://broadrouter.com/hi/models/deepseek-v4.1-flash/) के 1,048,576 टोकन पर भी।

## रात भर के रन से पहले की चेकलिस्ट

1.  क्लाइंट पर timeout और `max_retries` साफ़-साफ़ सेट।
2.  स्ट्रीमिंग चालू, `include_usage` के साथ, और अधूरी स्ट्रीम retry होती है।
3.  हर टास्क पर retry बजट और wall-clock सीमा।
4.  लिखने, भेजने या भुगतान करने वाले हर tool पर idempotency key।
5.  हर चरण के बाद checkpoint, atomic तरीक़े से लिखा हुआ।
6.  चरण संख्या, अवधि, टोकन और `X-Request-ID` वाले लॉग।

अगर आप कई एजेंट साथ-साथ चलाते हैं, तो [फ़्लैट रेट पर समानांतर कोडिंग एजेंट चलाना](https://broadrouter.com/hi/blog/run-parallel-coding-agents-flat-rate/) और [मल्टी-एजेंट सेटअप का ख़र्च](https://broadrouter.com/hi/blog/multi-agent-cost/) पढ़ें।

## BroadNet Inference कहाँ फ़िट होता है

BroadNet Inference मानक chat-completions स्ट्रीमिंग इस्तेमाल करता है, लॉग करने लायक `X-Request-ID` हेडर लौटाता है, और डॉक्यूमेंट करता है कि कौन-से एरर retry करने हैं, इसलिए ऊपर के पैटर्न जैसे लिखे हैं वैसे ही काम करते हैं। दिन भर चलने वाले एजेंट के लिए अनलिमिटेड प्लान DeepSeek V4.1 Flash पर टोकन मीटर हटा देते हैं, $60 प्रति महीना प्रति सेशन, जिससे retry मुफ़्त हो जाते हैं। ध्यान रखें कि Meteor का घंटा ख़रीदने के एक घंटे बाद और Orbit का हफ़्ता सात दिन बाद ख़त्म होता है, इसलिए लंबे काम को उस अवधि के भीतर पूरा होना चाहिए या रिन्यू होने वाले Full Moon सेशन पर जाना चाहिए। प्लान [inference.broadnet.ai/plans](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-long-running-agents-timeouts-retries&utm_content=body) पर हैं।

इस विषय के मुफ़्त टूल (अंग्रेज़ी में)

-   [Agent run cost estimator](https://broadrouter.com/tools/agent-run-cost-estimator/) Context growth per step, total tokens and cost of one agent run, with a DeepSeek session comparison.
-   [LLM batch job planner](https://broadrouter.com/tools/llm-batch-job-planner/) Run time, binding limit, cost per model and the flat sessions needed to finish a big job by a deadline.
-   [Flat-rate vs per-token LLM cost calculator](https://broadrouter.com/tools/flat-rate-vs-per-token-calculator/) Break-even between an unlimited plan and paying per token, per agent.
-   [LLM rate limit and concurrency calculator](https://broadrouter.com/tools/llm-rate-limit-calculator/) Which limit binds first: RPM, TPM or concurrency, with Little's law.

[मुफ़्त टूल (अंग्रेज़ी में)](https://broadrouter.com/tools/)

## इस लेख के शब्द

[AI एजेंट (AI agent)](https://broadrouter.com/hi/glossary/agent/)

AI एजेंट ऐसा सिस्टम है जिसमें लैंग्वेज मॉडल किसी लक्ष्य की ओर अपने क़दम ख़ुद तय करता है: कौन-से टूल कॉल करने हैं, चुनता है, नतीजे पढ़ता है और अंतिम जवाब या किसी सीमा तक दोहराता रहता है। तय बिंदुओं पर मॉडल को कॉल करने वाली स्क्रिप्ट को आम तौर पर workflow कहते हैं।

[स्ट्रीमिंग (streaming)](https://broadrouter.com/hi/glossary/streaming/)

स्ट्रीमिंग, लैंग्वेज मॉडल के जवाब को अंत में एक साथ लौटाने के बजाय, बनते समय ही छोटे-छोटे टुकड़ों (chunks) में लौटाने का तरीक़ा है। OpenAI-कम्पैटिबल API, अनुरोध में stream को true सेट करने पर server-sent events से स्ट्रीम करते हैं।

[Idempotency key (आइडेम्पोटेंसी key)](https://broadrouter.com/hi/glossary/idempotency-key/)

Idempotency key एक यूनिक वैल्यू है, आम तौर पर UUID जैसी रैंडम ID, जिसे क्लाइंट स्टेट बदलने वाले अनुरोध, जैसे पेमेंट या ख़रीद, के साथ जोड़ता है। अगर वही अनुरोध उसी key के साथ दोबारा आए, तो सर्वर काम दो बार करने के बजाय पहला नतीजा लौटाता है।

[टोकन (token)](https://broadrouter.com/hi/glossary/token/)

टोकन टेक्स्ट की वह इकाई है जिसे लैंग्वेज मॉडल पढ़ता और लिखता है: कोई शब्द, शब्द का हिस्सा, विराम चिह्न या बाइट का क्रम, जो मॉडल का टोकनाइज़र बनाता है। LLM API इस्तेमाल को टोकन में गिनते हैं, उसी में लिमिट लगाते हैं और आम तौर पर बिल भी बनाते हैं।

[उपयोग के अनुसार भुगतान (pay-as-you-go)](https://broadrouter.com/hi/glossary/pay-as-you-go/)

उपयोग के अनुसार भुगतान (pay-as-you-go) एक प्राइसिंग मॉडल है जिसमें आप सिर्फ़ उतना देते हैं जितना इस्तेमाल करते हैं, जिसे टोकन, अनुरोध या ऑडियो मिनट जैसी इकाइयों में मापा जाता है, बिना सब्सक्रिप्शन या न्यूनतम प्रतिबद्धता के। ज़्यादातर LLM API इसी तरह बिल बनाते हैं, प्रीपेड बैलेंस या समय-समय पर बनने वाले इनवॉइस से।

[रेट लिमिट (rate limit)](https://broadrouter.com/hi/glossary/rate-limit/)

रेट लिमिट वह सीमा है जो कोई API तय करता है कि एक क्लाइंट किसी समय-अवधि में उसका कितना इस्तेमाल कर सकता है, जैसे प्रति मिनट अनुरोध या प्रति मिनट टोकन। सीमा से ऊपर के अनुरोध ठुकरा दिए जाते हैं, आम तौर पर HTTP 429 Too Many Requests के साथ, जब तक इस्तेमाल फिर सीमा के नीचे न आ जाए।

[एक्सपोनेंशियल बैकऑफ़ (exponential backoff)](https://broadrouter.com/hi/glossary/exponential-backoff/)

एक्सपोनेंशियल बैकऑफ़ री-ट्राई की एक रणनीति है जिसमें क्लाइंट हर नाकाम कोशिश के बाद, दोबारा कोशिश करने से पहले, ज़्यादा देर इंतज़ार करता है, आम तौर पर देरी को एक सीमा तक दोगुना करते हुए। हर इंतज़ार में रैंडम jitter जोड़ने से कई क्लाइंट के री-ट्राई बिखर जाते हैं, ताकि वे एक ही पल सर्वर पर न पहुँचें।

[कॉन्करेंसी (concurrency)](https://broadrouter.com/hi/glossary/concurrency/)

कॉन्करेंसी, किसी क्लाइंट के एक ही समय पर चल रहे (in-flight) अनुरोधों की संख्या है। LLM API अक्सर इसकी सीमा हर key या प्लान पर, प्रति मिनट अनुरोधों से अलग रखते हैं, क्योंकि हर खुला अनुरोध जवाब पूरा होने तक GPU क्षमता घेरे रहता है।

## अक्सर पूछे जाने वाले सवाल

### एजेंट में LLM API कॉल के लिए कितना timeout रखना चाहिए?

इतना लंबा कि सबसे धीमी जायज़ कॉल पूरी हो जाए, और इतना छोटा कि अटकी हुई कॉल पकड़ी जाए। OpenAI Python SDK का डिफ़ॉल्ट 10 मिनट है। कई एजेंट स्ट्रीमिंग के साथ हर कॉल पर 2 से 5 मिनट रखते हैं, और हर टास्क के लिए अलग wall-clock सीमा।

### एजेंट को कौन-से LLM API एरर retry करने चाहिए?

कनेक्शन एरर, 429 और 5xx को सीमित exponential backoff और jitter के साथ retry करें। 400, 401, 402, 403, 413 और 422 को retry करने के बजाय ठीक करें। BroadNet पर हर विफलता के लिए X-Request-ID हेडर भी लॉग करें।

### क्या chat completion को retry करना सुरक्षित है?

मॉडल कॉल का अपना कोई side effect नहीं होता, इसलिए हाँ, लेकिन यह नया inference है और उपयोग के अनुसार भुगतान में इसका फिर से बिल बनता है। ख़तरा tools में है। retry किया गया चरण ईमेल दो बार भेज सकता है, जब तक tool idempotency key इस्तेमाल न करे।

### क्रैश के बाद एजेंट को दोबारा कैसे शुरू करूँ?

हर पूरे हुए चरण के बाद मैसेज लिस्ट और चरण संख्या सेव करें, कोई एक्शन लेने से पहले side effect के ID लिखें, और शुरू होते समय उन्हें लोड करें। एजेंट आख़िरी सेव किए गए चरण से आगे चलता है।

### क्या लंबे चलने वाले एजेंट के लिए अनलिमिटेड प्लान ज़रूरी है?

नहीं, लेकिन उपयोग के अनुसार भुगतान में retry और लंबे कॉन्टेक्स्ट का ख़र्च जुड़ता जाता है। BroadNet के अनलिमिटेड प्लान पर DeepSeek V4.1 Flash में टोकन मीटर नहीं है, इसलिए retry का अतिरिक्त ख़र्च नहीं, हालाँकि हर सेशन फिर भी एक समय में एक अनुरोध चलाता है।

## आगे पढ़ें

-   [ओपन मॉडल के साथ टूल कॉलिंग: स्कीमा, पैरेलल कॉल, रीट्राई](https://broadrouter.com/hi/blog/tool-calling-open-models/)
-   [मल्टी-एजेंट सेटअप की असली लागत: प्रति टोकन बनाम फ़्लैट सेशन](https://broadrouter.com/hi/blog/multi-agent-cost/)
-   [फ़्लैट-रेट LLM API पर पैरेलल कोडिंग एजेंट कैसे चलाएँ](https://broadrouter.com/hi/blog/run-parallel-coding-agents-flat-rate/)
-   [LLM API प्लान में “अनलिमिटेड” का असली मतलब क्या है?](https://broadrouter.com/hi/blog/what-unlimited-llm-api-really-means/)
-   [LLM API फ़ेलओवर: अपने कोड में दूसरे प्रोवाइडर पर फ़ॉलबैक](https://broadrouter.com/hi/blog/llm-api-failover-fallback/)
-   [AI कोडिंग एजेंट के एक रन की लागत: स्टेप, कॉन्टेक्स्ट और कैशिंग](https://broadrouter.com/hi/blog/ai-coding-agent-run-cost/)
-   [ओपन मॉडल के साथ Claude Code: प्रॉक्सी, नेटिव एंडपॉइंट और सीमाएँ](https://broadrouter.com/hi/blog/claude-code-with-openai-compatible-models/)
-   [गाइड: BroadNet Inference के एरर कोड और रीट्राई कब करें](https://broadrouter.com/hi/guides/errors-and-retries/)
-   [गाइड: chat completions स्ट्रीम करें और टूटे कनेक्शन सँभालें](https://broadrouter.com/hi/guides/streaming-chat-completions/)
-   [गाइड: एजेंट के लिए अनलिमिटेड LLM API प्लान कैसे काम करते हैं](https://broadrouter.com/hi/guides/unlimited-llm-api-sessions/)
-   [गाइड: BroadNet Inference के साथ OpenAI Python SDK इस्तेमाल करें](https://broadrouter.com/hi/guides/openai-python-sdk/)

इसे अपने असली वर्कलोड पर आज़माएँ। नए अकाउंट Gemma और ट्रांसक्रिप्शन के लिए US$5 के क्रेडिट से शुरू होते हैं। DeepSeek, GLM, और Qwen3.8 के लिए टॉप-अप ज़रूरी है।

[शुरू करें](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-long-running-agents-timeouts-retries&utm_content=page-cta) ·

**स्रोत**

-   [OpenAI Python SDK README, retry और timeout (2026-11-14 को जाँचा गया)](https://github.com/openai/openai-python)
-   [BroadNet Inference API रेफ़रंस, एरर और retry (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-long-running-agents-timeouts-retries&utm_content=sources#errors)
-   [BroadNet Inference API रेफ़रंस, स्ट्रीमिंग और सीमाएँ (अंग्रेज़ी में)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-long-running-agents-timeouts-retries&utm_content=sources#requests)
-   [BroadNet Inference के अनलिमिटेड प्लान (अंग्रेज़ी में)](https://inference.broadnet.ai/plans?utm_source=broadrouter&utm_medium=referral&utm_campaign=hi-blog-long-running-agents-timeouts-retries&utm_content=sources)
