> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flexinference.com/llms.txt
> Use this file to discover all available pages before exploring further.

# समय-सीमा रूटिंग

> start_within फ़ील्ड, flex रेस, और standard में स्वचालित वृद्धि।

`start_within` हर FlexInference अनुरोध पर आवश्यक है। यह निर्धारित करता है कि राउटर अनुरोध शुरू होने के लिए कितनी देर तक प्रतीक्षा कर सकता है। जब आप सीधे किसी प्रोवाइडर टियर को चाहते हैं, तो `default`, `priority`, या `auto` का उपयोग करें। जब आप चाहते हैं कि FlexInference पहले flex-सक्षम मॉडल पर flex को आज़माए, फिर यदि flex समय पर शुरू नहीं हो पाता है तो standard में वृद्धि करे, तो एक अवधि का उपयोग करें।

फ़ील्ड के चार रूप हैं।

## चार रूप

<Tabs>
  <Tab title="डिफ़ॉल्ट">
    ```json theme={null}
    { "start_within": "default" }
    ```

    प्रोवाइडर के **standard** रीयल-टाइम टियर पर standard मूल्य निर्धारण पर रूट करता है: OpenAI का `default`, Gemini का `standard`, या Anthropic का `standard_only`। किसी भी मॉडल के साथ काम करता है।
  </Tab>

  <Tab title="प्राथमिकता">
    ```json theme={null}
    { "start_within": "priority" }
    ```

    सबसे तेज़ शुरुआत के लिए OpenAI के **priority** टियर पर रूट करता है। इसका उपयोग इंटरैक्टिव, विलंबता-महत्वपूर्ण पाथ के लिए करें। Priority सबसे महंगा टियर है। किसी भी मॉडल के साथ काम करता है। Anthropic पर यह **best-effort** है क्योंकि Claude का कोई priority टियर नहीं है; हम इसे Anthropic के `auto` पर मैप करते हैं।
  </Tab>

  <Tab title="ऑटो">
    ```json theme={null}
    { "start_within": "auto" }
    ```

    प्रोवाइडर को टियर चुनने देता है। OpenAI पर यह `service_tier: auto` है; Anthropic पर यह Anthropic के `auto` पर मैप होता है। यह प्रोवाइडर का auto टियर है, FlexInference auto-routing नहीं। **OpenAI और Anthropic** पर काम करता है। Gemini का कोई auto टियर नहीं है, इसलिए Gemini मॉडल पर `auto` `400 auto_unsupported_for_gemini` लौटाता है।
  </Tab>

  <Tab title="एक अवधि">
    ```json theme={null}
    { "start_within": "00h-00m-30s" }
    ```

    `/v1/responses`, `/v1/chat/completions`, `/v1/interactions`, और `/v1/messages` सहित हर endpoint पर **flex race** (नीचे) का अनुरोध करता है। FlexInference पहले सस्ते flex टियर को आज़माता है और केवल तभी standard पर जाता है जब flex विंडो के भीतर शुरू नहीं हो पाता। अवधि अनुरोध शुरू होने की अधिकतम प्रतीक्षा है, जिसे `HHh-MMm-SSs` के रूप में लिखा जाता है जिसमें प्रत्येक फ़ील्ड के लिए दो अंक होते हैं। यह **5 सेकंड और 10 मिनट** (`00h-00m-05s` से `00h-10m-00s`) के बीच होना चाहिए।
  </Tab>
</Tabs>

`default`, `priority`, और `auto` **किसी भी** मॉडल को उसके प्रोवाइडर (OpenAI, Gemini, या Anthropic) को प्रॉक्सी करते हैं। केवल एक अवधि flex race का अनुरोध करती है। यदि मॉडल flex का उपयोग नहीं कर सकता है, तो एक अवधि `400` (`flex_unsupported_for_anthropic` या `flex_model_not_capable`) लौटाती है; इसके बजाय एक टियर मान का उपयोग करें।

<Note>
  flex race **Claude पर उपलब्ध नहीं है** क्योंकि Anthropic का कोई flex
  टियर नहीं है। `claude-*` मॉडल पर एक अवधि `start_within` `400
      flex_unsupported_for_anthropic` लौटाती है। Anthropic अभी भी `default`,
  `priority`, और `auto` टियर प्रॉक्सी अनुरोधों के साथ काम करता है।
</Note>

<Note>
  एक अवधि `start_within` को native-only Chat Completions
  पैरामीटर जैसे `logprobs` या `seed` के साथ नहीं जोड़ा जा सकता है। उन पैरामीटरों को हटा दें, या इसके बजाय
  `default`, `priority`, या `auto` का उपयोग करें।
</Note>

## flex रेस

एक अवधि के साथ, FlexInference पहले प्रोवाइडर के **flex** टियर (OpenAI या Gemini) का प्रयास करता है। Flex को standard दर के आधे पर बिल किया जाता है, लेकिन क्षमता best-effort होती है। राउटर आपके विंडो के भीतर अपस्ट्रीम अनुरोध शुरू होने की प्रतीक्षा करता है:

<Steps>
  <Step title="flex को फायर करें">
    FlexInference आपके अनुरोध को flex टियर पर भेजता है और प्रोवाइडर द्वारा इसकी पूर्ति की पुष्टि करने की प्रतीक्षा करता है, यह सब आपके द्वारा निर्धारित समय के भीतर होता है।
  </Step>

  <Step title="flex के लिए प्रतिबद्ध">
    यदि प्रोवाइडर समय पर अनुरोध शुरू करता है, तो FlexInference प्रतिबद्ध होता है। आपकी प्रतिक्रिया सामान्य रूप से स्ट्रीम होती है, जिसे flex दरों पर बिल किया जाता है। प्रतिक्रिया `"service_tier": "flex"` दिखाती है।
  </Step>

  <Step title="standard में वृद्धि करें">
    यदि flex समय पर शुरू नहीं हो पाता है, तो FlexInference इसे रद्द कर देता है और अनुरोध को standard पर भेजता है। यह सस्ते flex से standard तक की वृद्धि है, न कि downgrade। प्रतिक्रिया `"service_tier": "default"` (OpenAI) या `"standard"` (Gemini) दिखाती है।
  </Step>
</Steps>

standard में वृद्धि केवल flex शुरू होने से पहले होती है, जब flex `429` (कोई क्षमता नहीं), कोई `5xx`, प्री-स्टार्ट विफलता, या समय-सीमा से पहले कोई शुरुआत नहीं लौटाता है। flex-से-standard स्विच **एकमात्र** टियर परिवर्तन है जो FlexInference करता है। एक प्रोवाइडर फ़ॉलबैक, जहाँ आप एक वैकल्पिक `provider` array सेट करते हैं और FlexInference एक रूट के अस्थायी रूप से विफल होने के बाद अगले रूट का प्रयास करता है, रूट को बदलता है, टियर या मॉडल को कभी नहीं। आपके द्वारा नामित किसी भी रूट के लिए एक गुम key एक अस्थायी विफलता के बजाय एक कॉन्फ़िगरेशन त्रुटि है, इसलिए यह फ़ॉल-थ्रू होने के बजाय `400` लौटाता है। [provider routing](/hi/models) देखें।

<Info>
  सबसे लंबी अवधि चुनें जिसे आपका UX सहन कर सकता है। लंबी विंडो flex को जीतने के लिए अधिक समय देती हैं, जिससे सस्ती दर पर सेवा दिए गए अनुरोधों का हिस्सा बढ़ जाता है।
</Info>

## परिणाम पढ़ना

सफल `200` प्रतिक्रियाओं में स्ट्रीमिंग और नॉन-स्ट्रीमिंग दोनों कॉल के लिए हर endpoint पर Flex परिणाम हेडर शामिल होते हैं। त्रुटि प्रतिक्रियाएं इसके बजाय त्रुटि बॉडी का उपयोग करती हैं।

| Header                             | Meaning                                                                                                                                                                                                                                                                                                                                                            |
| ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `x-flexinference-flex-requested`   | `true` जब कॉलर ने एक अवधि `start_within` भेजी; जब कॉलर ने `default`, `priority`, या `auto` भेजा तो `false`।                                                                                                                                                                                                                                                        |
| `x-flexinference-flex-applied`     | `true` केवल तभी जब flex ने प्रतिक्रिया दी।                                                                                                                                                                                                                                                                                                                         |
| `x-flexinference-flex-reason`      | मशीन-पठनीय परिणाम। नीचे मान देखें।                                                                                                                                                                                                                                                                                                                                 |
| `x-flexinference-provider-surface` | प्लानर द्वारा चयनित प्रोवाइडर surface। मान `openai.responses`, `openai.chat`, `gemini.interactions`, और `anthropic.messages` हैं। यह कॉलर endpoint से भिन्न हो सकता है। एक `/v1/chat/completions` कॉल एक OpenAI मॉडल के साथ `openai.responses` रिपोर्ट करता है जब तक कि native Chat passthrough की आवश्यकता न हो, ऐसी स्थिति में यह `openai.chat` रिपोर्ट करता है। |

लाइव `x-flexinference-flex-reason` मान हैं:

| Reason           | Meaning                                                                                                               |
| ---------------- | --------------------------------------------------------------------------------------------------------------------- |
| `not_requested`  | अनुरोध ने `default`, `priority`, या `auto` का उपयोग किया; कोई flex race का अनुरोध नहीं किया गया था।                   |
| `flex_committed` | flex race प्रतिबद्ध। प्रतिक्रिया `service_tier: "flex"` और `x-flexinference-flex-applied: true` दिखाती है।            |
| `flex_lost_race` | अनुरोध ने flex-सक्षम मॉडल पर एक अवधि का उपयोग किया, लेकिन flex समय पर शुरू नहीं हुआ और अनुरोध standard पर वापस आ गया। |

<Note>
  एक अवधि जो flex race नहीं चला सकती है, `400` लौटाती है
  (`claude-*` मॉडल पर `flex_unsupported_for_anthropic`,
  गैर-flex-सक्षम OpenAI/Gemini मॉडल पर `flex_model_not_capable`); हेडर कारण केवल उन अनुरोधों का वर्णन करते हैं जिन्होंने flex चलाया या इसका अनुरोध नहीं किया।
</Note>

## जब flex पूल अनुपलब्ध हो

flex टियर साझा, best-effort क्षमता का उपयोग करता है। अनुरोध शुरू होने से पहले, flex `429` लौटा सकता है जब कोई क्षमता नहीं होती है, कोई `5xx` लौटा सकता है, प्री-स्टार्ट विफल हो सकता है, या समय-सीमा चूक सकता है। FlexInference तब अनुरोध को standard पर भेजता है।

दुर्लभ मामलों में, flex अनुरोध स्वीकार किए जाने और स्ट्रीमिंग शुरू होने के *बाद* विफल हो जाता है। FlexInference उस विफलता को उजागर करता है। एक स्ट्रीमिंग अनुरोध पर आपको एक टर्मिनल `response.failed` इवेंट मिलता है। एक नॉन-स्ट्रीमिंग अनुरोध पर आपको `502` मिलता है। यह प्रतिबद्धता के बाद पुनः प्रयास नहीं करता क्योंकि इससे एक अधूरा अनुरोध मास्क हो सकता है। यदि आप इससे टकराते हैं, तो **पुनः प्रयास करें**, या flex को छोड़ने के लिए `default`, `priority`, या `auto` का उपयोग करें।

## ट्रांसपोर्ट पुनः प्रयास

flex race यह तय करता है कि कौन सा टियर आपके अनुरोध को सेवा देगा। ट्रांसपोर्ट पुनः प्रयास यह तय करता है कि जब वह टियर शुरू होने में विफल रहता है तो क्या होता है। एक वैकल्पिक `retry` ऑब्जेक्ट जोड़ें और FlexInference प्रतीक्षा करता है और एक अस्थायी अपस्ट्रीम विफलता पर सेटल किए गए टियर को फिर से हिट करता है, बजाय इसके कि आपको त्रुटि लौटाए।

```json theme={null}
{ "retry": { "count": 2 } }
```

| Field     | Required | Values                                   | Meaning                                                                                                                             |
| --------- | -------- | ---------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| `count`   | हाँ      | पूर्णांक, `1` से `5`                     | पहले प्रयास के विफल होने के बाद सेटल किए गए टियर के पुनः हिट।                                                                       |
| `backoff` | नहीं     | `"exponential"` (डिफ़ॉल्ट) या `"linear"` | प्रयासों के बीच प्रतीक्षा पैटर्न। Exponential 0.5s से शुरू होता है और 8s तक दोगुना हो जाता है; linear हर बार 0.5s जोड़ता है, 8s तक। |
| `jitter`  | नहीं     | बूलियन (डिफ़ॉल्ट `true`)                 | प्रतीक्षा को फैलाता है ताकि बर्स्ट को सुचारू किया जा सके। Jitter केवल प्रतीक्षा को छोटा करता है, कभी लंबा नहीं करता।                |

एक अमान्य `retry` `400` [`invalid_retry`](/hi/errors#invalid_retry) लौटाता है।

FlexInference केवल सेटल किए गए टियर से एक वास्तविक प्री-कमिट ट्रांसपोर्ट विफलता को पुनः प्रयास करता है: एक वास्तविक `429`, एक वास्तविक `5xx`, या एक कनेक्शन जो कभी नहीं खुला ([`upstream_unavailable`](/hi/errors#upstream_unavailable))। यह क्लाइंट `4xx`, एक अपस्ट्रीम auth विफलता ([`upstream_auth_failed`](/hi/errors#upstream_auth_failed)), एक अपस्ट्रीम timeout ([`upstream_timeout`](/hi/errors#upstream_timeout)), या क्लाइंट द्वारा रद्द किए गए अनुरोध को पुनः प्रयास नहीं करता है। वे या तो पुनः हिट पर उसी तरह विफल होते हैं या इसका मतलब है कि कॉलर पहले ही चला गया है।

पुनः प्रयास उस टियर को फिर से हिट करता है जिसने आपके अनुरोध को सेटल किया, न कि flex लेग को। `default`, `priority`, या `auto` अनुरोध पर वह टियर है जिसे आपने नामित किया था। एक अवधि अनुरोध पर जो flex race हार जाता है, वह standard टियर है जिस पर आपने वृद्धि की थी। flex प्रयास और वृद्धि flex race का अपना काम है और `count` के विरुद्ध कभी नहीं गिना जाता है। एक टियर को ऊपर बढ़ाना और उसी टियर को पुनः प्रयास करना अलग-अलग चरण हैं जो श्रृंखला बनाते हैं: flex standard से हार जाता है, फिर standard खुद को पुनः प्रयास कर सकता है।

जब प्रोवाइडर `Retry-After` हेडर भेजता है, तो FlexInference बैकऑफ़ शेड्यूल के बजाय उतनी देर प्रतीक्षा करता है, जिसे 60 सेकंड तक सीमित किया जाता है ताकि एक खराब मान आपके अनुरोध को पार्क न कर सके।

<Note>
  पुनः प्रयास केवल प्री-कमिट होता है। यह उस क्षण रुक जाता है जब एक टियर प्रतिबद्ध होता है, जो स्ट्रीमिंग और नॉन-स्ट्रीमिंग दोनों कॉल के लिए `200` स्टेटस लाइन है। एक बार जब पहला बाइट आप तक पहुंच जाता है, तो FlexInference कभी पुनः प्रयास नहीं करता है, वही नियम जो flex race प्रतिबद्धता के बाद पालन करता है। एक मिड-स्ट्रीम विफलता, या एक प्रतिबद्ध `200` के बाद एक नॉन-स्ट्रीमिंग `502`, आप तक पहुंच जाती है।
</Note>

सर्वर-साइड `retry` आपके क्लाइंट में किसी भी पुनः प्रयास लूप से अलग है, और दोनों स्टैक होते हैं। FlexInference SDK पुनः प्रयास नहीं करते हैं, लेकिन एक स्टॉक OpenAI या Anthropic SDK डिफ़ॉल्ट रूप से दो बार पुनः प्रयास करता है। एक क्लाइंट जो सर्वर `count` के `3` के ऊपर दो बार पुनः प्रयास करता है, छह अपस्ट्रीम प्रयासों तक चलाता है, क्योंकि प्रत्येक क्लाइंट प्रयास एक पूर्ण सर्वर बजट चलाता है। जब आप `retry` सेट करते हैं, तो FlexInference प्रतिक्रिया पर `x-flexinference-retries` को उन पुनः हिट की संख्या के साथ स्टैंप करता है जिन्हें उसने चलाया था, ताकि आप अपने क्लाइंट के `max_retries` को कम कर सकें।

## बिलिंग

BYOK के साथ, FlexInference आपके संग्रहीत एन्क्रिप्टेड प्रोवाइडर key का सर्वर-साइड उपयोग करता है; आप प्रति अनुरोध प्रोवाइडर key नहीं भेजते हैं। आपका प्रोवाइडर आपके खाते को उस टियर की दर पर बिल करता है जिसने अनुरोध को सेवा दी थी। जब flex प्रतिबद्ध होता है तो आप flex दरें और वृद्धि के बाद standard दरें चुकाते हैं। एक flex प्रयास विफल होने से पहले कुछ token जला सकता है। आपका प्रोवाइडर उस उपयोग को उसी तरह बिल करता है जैसे वह सीधे flex को कॉल करने पर करता, और FlexInference इसे उपयोग में शामिल करता है। FlexInference आपके token पर कोई मार्कअप नहीं जोड़ता है। यह आपके द्वारा बचाए गए पैसे का 20% चार्ज करता है, और जब कोई बचत नहीं होती है तो कुछ भी चार्ज नहीं करता है।

## FlexInference क्या बदलता है

FlexInference टियर को बदल सकता है। यह आपके अनुरोध के अर्थ या प्रोवाइडर के परिणाम को नहीं बदलता है। यह प्रोवाइडर की स्थिति या संदेश को कभी भी फिर से नहीं लिखता है। यह केवल त्रुटि लिफाफे को सामान्य करता है: एक त्रुटि आपके द्वारा बुलाए गए endpoint (responses और chat पर OpenAI, messages पर Anthropic, interactions पर Google) के आकार में लौटाई जाती है, जिसमें प्रोवाइडर की स्थिति और संदेश होता है, ताकि आपका SDK इसे पार्स कर सके। [Errors](/hi/errors) देखें।

<Note>
  `start_within` **आवश्यक** है। इसके बिना, अनुरोध `400
      missing_start_within` लौटाता है, जिसमें हमारे बेस URL पर इंगित एक सादा OpenAI SDK भी शामिल है। यदि आप एक ऐसा मान भेजते हैं जिसे FlexInference पढ़ नहीं सकता है, तो आपको
  `invalid_start_within` मिलता है। वैध मान `"default"`, `"priority"`, `"auto"`,
  या `"00h-00m-30s"` जैसी अवधि हैं। केवल `standard` शब्द पहले अनुमत था और अब नहीं है, इसलिए इसके बजाय `default` भेजें। पूरी सूची के लिए [Errors](/hi/errors) देखें।
</Note>