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

# OpenCode

> केवल कॉन्फ़िग के साथ OpenCode को FlexInference पर इंगित करें।

OpenCode बिना किसी स्रोत परिवर्तन या फोर्क के, एक JSON फ़ाइल से एक प्रोवाइडर एंट्री पढ़ता है।

OpenCode कॉन्फ़िग में `start_within` सेट कर सकता है, इसलिए यहां एक एजेंट key वैकल्पिक है। key अभी भी एक सरल तरीका है, क्योंकि यह बिना रीस्टार्ट के बदल जाती है। [एजेंट key](/hi/agent-keys) देखें।

## इसे एक एजेंट के साथ सेट करें

नीचे दिए गए ब्लॉक को खोलें और इसे किसी भी कोडिंग एजेंट में कॉपी करें। प्रॉम्प्ट कभी भी आपकी API key नहीं मांगेगा: एजेंट बाकी सब कॉन्फ़िगर करता है, फिर आपके लिए चलाने के लिए एक एक्सपोर्ट लाइन प्रिंट करता है।

<Accordion title="एजेंट सेटअप प्रॉम्प्ट कॉपी करें">
  ```text theme={null}
  Configure OpenCode to send its requests to FlexInference. This is config only: no source change, no fork, no patch.

  You will never see or handle my API key. The provider entry stores only the `{env:FLEXINFERENCE_API_KEY}` template, and I export the value myself. Do not ask me for the key, and do not read it from my environment.

  Ask me whether this should apply to every project or one project, then write the provider entry to the matching file. Global is `~/.config/opencode/opencode.json`. Per project is `opencode.json` in the project root. Project config wins over global. Create the file if it does not exist, and merge into it rather than overwriting anything already there.

  The entry:

  {
    "$schema": "https://opencode.ai/config.json",
    "model": "flexinference/gpt-5.6-sol",
    "provider": {
      "flexinference": {
        "name": "FlexInference",
        "env": ["FLEXINFERENCE_API_KEY"],
        "npm": "@ai-sdk/openai-compatible",
        "options": {
          "apiKey": "{env:FLEXINFERENCE_API_KEY}",
          "baseURL": "https://api.flexinference.com/v1"
        },
        "models": {
          "gpt-5.6-sol": {
            "name": "GPT-5.6 Sol",
            "reasoning": true,
            "tool_call": true,
            "limit": { "context": 400000, "output": 128000 }
          }
        }
      }
    }
  }

  Then print this line for me to run in the shell I start OpenCode from. Do not run it and do not ask for the value:

      export FLEXINFERENCE_API_KEY=<paste your key here>

  Rules that matter, do not deviate:
  - Keep `options.apiKey` as the literal `{env:FLEXINFERENCE_API_KEY}` template. Never inline my key.
  - The top-level `model` field is what selects the provider. Without it OpenCode stays on its built-in default and never reaches FlexInference.
  - `options.baseURL` must end in `/v1`.
  - Every key under `models` is a slug sent verbatim on the wire, so it must be one FlexInference serves. `gpt-5.6-sol` is a safe default.
  - Do not put `seed`, `stop`, `presence_penalty`, `frequency_penalty`, `logit_bias`, `logprobs`, `top_logprobs`, `prediction`, `audio`, `modalities`, or `web_search_options` in any model's `options`. FlexInference refuses those Chat Completions parameters, and they also conflict with a key that carries a flex duration.
  - Do not add `start_within` unless I ask. My agent key already carries the deadline, and a key duration falls back safely on models that cannot race while a config duration errors.
  - If I mention working in repositories I do not control, tell me to set `OPENCODE_DISABLE_PROJECT_CONFIG`. A project config wins over the global one and can repoint `baseURL` while still reading my exported key. `OPENCODE_CONFIG` does not prevent that, because project config loads after it.

  Verify the file is valid JSON, then report what you changed and which file you wrote.
  ```
</Accordion>

## OpenCode कॉन्फ़िगर करें

1. OpenCode शुरू करने वाले शेल में key एक्सपोर्ट करें।

   ```bash theme={null}
   export FLEXINFERENCE_API_KEY=flex_live_...
   ```

2. प्रोवाइडर एंट्री को `opencode.json` में लिखें।

   ```json theme={null}
   {
     "$schema": "https://opencode.ai/config.json",
     "model": "flexinference/gpt-5.6-sol",
     "provider": {
       "flexinference": {
         "name": "FlexInference",
         "env": ["FLEXINFERENCE_API_KEY"],
         "npm": "@ai-sdk/openai-compatible",
         "options": {
           "apiKey": "{env:FLEXINFERENCE_API_KEY}",
           "baseURL": "https://api.flexinference.com/v1"
         },
         "models": {
           "gpt-5.6-sol": {
             "name": "GPT-5.6 Sol",
             "reasoning": true,
             "tool_call": true,
             "limit": { "context": 400000, "output": 128000 }
           }
         }
       }
     }
   }
   ```

3. उस फ़ाइल के विरुद्ध OpenCode शुरू करें।

   ```bash theme={null}
   OPENCODE_CONFIG=/path/to/opencode.json opencode
   ```

चार फ़ील्ड इंटीग्रेशन को संभालते हैं। `npm` OpenAI-संगत पैकेज चुनता है। `options.baseURL` राउटर को रिक्वेस्ट भेजता है। `options.apiKey` एनवायरनमेंट से key पढ़ता है। `models` के तहत प्रत्येक key एक slug है जिसे हम चलाते हैं।

`models` के तहत एक key जोड़कर एक मॉडल जोड़ें। एंट्री में बाकी सब डिस्प्ले और लिमिट्स हैं।

## ग्लोबल या प्रति प्रोजेक्ट

आप इसे कितनी व्यापक रूप से चाहते हैं, इसके आधार पर प्रोवाइडर एंट्री को दो स्थानों में से एक में रखें।

| दायरा           | पाथ                                 | लागू होता है                     |
| --------------- | ----------------------------------- | -------------------------------- |
| ग्लोबल          | `~/.config/opencode/opencode.json`  | इस मशीन पर हर प्रोजेक्ट          |
| प्रति प्रोजेक्ट | `opencode.json` in the project root | केवल वह प्रोजेक्ट                |
| एक रन           | any path, via `OPENCODE_CONFIG`     | जिस लॉन्च को आप इसे पास करते हैं |

**प्रोजेक्ट कॉन्फ़िग ग्लोबल पर हावी होता है।** OpenCode वर्किंग डायरेक्टरी में `opencode.json` की तलाश करता है और निकटतम Git डायरेक्टरी तक ऊपर जाता है, ताकि एक रेपो आपके मशीन-व्यापी प्रोवाइडर को छुए बिना उसे ओवरराइड कर सके।

प्रोवाइडर एंट्री को ग्लोबल फ़ाइल में रखें और डेडलाइन हर जगह समान रहेगी। इसे एक प्रोजेक्ट फ़ाइल में रखें और केवल वही रेपो हमारे माध्यम से रूट करेगा।

ऊपर की ओर खोज को रोकने के लिए `OPENCODE_DISABLE_PROJECT_CONFIG` सेट करें।

बंडलों और ऑटोमेशन के लिए दो और स्रोत मौजूद हैं। `OPENCODE_CONFIG_DIR` एक डायरेक्टरी का नाम देता है जिससे OpenCode कॉन्फ़िग पढ़ता है, और `OPENCODE_CONFIG_CONTENT` JSON को इनलाइन रखता है। प्रति रन एक फ़ाइल में ऑप्ट-इन करने के लिए `OPENCODE_CONFIG` का उपयोग करें।

```bash theme={null}
OPENCODE_CONFIG=/path/to/opencode.json opencode
```

## इसके बजाय कॉन्फ़िग में डेडलाइन सेट करें

OpenCode स्वयं `start_within` भेज सकता है। दोनों स्थान सादे JSON हैं, और दोनों key को मात देते हैं।

इसे प्रति मॉडल सेट करें। `options` ब्लॉक उस मॉडल के लिए रिक्वेस्ट बॉडी में जाता है।

```json theme={null}
"gpt-5.6-sol": {
  "name": "GPT-5.6 Sol",
  "options": { "start_within": "00h-00m-30s", "reasoningEffort": "medium" }
}
```

इसके बजाय इसे प्रति वेरिएंट सेट करें, ताकि मॉडल बदले बिना स्विच किया जा सके। `opencode run` पर `--variant` के साथ एक चुनें, या TUI में `ctrl+t` के साथ उन्हें साइकिल करें।

```json theme={null}
"gpt-5.6-sol": {
  "name": "GPT-5.6 Sol",
  "variants": {
    "patient": { "start_within": "00h-05m-00s", "reasoningEffort": "high" },
    "now": { "start_within": "priority", "reasoningEffort": "low" }
  }
}
```

यहां एक अवधि उस मॉडल पर विफल हो जाती है जो दौड़ नहीं सकता। key पर समान अवधि इसके बजाय वापस आ जाती है। यही कारण है कि key को प्राथमिकता दी जाती है।

## पुष्टि करें कि key लागू हो गई है

हर रिस्पॉन्स `x-flexinference-defaults-applied` के साथ आता है। OpenCode TUI में रिस्पॉन्स हेडर नहीं दिखाता है, इसलिए इसके बजाय डैशबोर्ड में **Logs** के तहत रिक्वेस्ट पढ़ें।

## समस्या निवारण

**रिक्वेस्ट हम तक कभी नहीं पहुंचती।** टॉप-लेवल `model` फ़ील्ड ही प्रोवाइडर का चयन करता है, इसलिए प्रोवाइडर को वहां नाम दिए बिना परिभाषित करने से OpenCode अपने बिल्ट-इन डिफ़ॉल्ट पर रहता है। `"model": "flexinference/<slug>"` सेट करें।

**[`401 invalid_api_key`](/hi/errors#invalid_api_key)।** OpenCode शुरू करने वाले शेल में `FLEXINFERENCE_API_KEY` अनसेट है। लॉन्च करने से पहले इसे एक्सपोर्ट करें, क्योंकि `options.apiKey` इसे एनवायरनमेंट से पढ़ता है।

**[`400 unsupported_parameter`](/hi/errors#unsupported_parameter)।** एक Chat Completions पैरामीटर जिसे हम ट्रांसलेट नहीं करते हैं, वह मॉडल के `options` में था, जैसे `seed` या `stop`। इसे एंट्री से हटा दें।

**[`400 key_default_not_applicable`](/hi/errors#key_default_not_applicable)।** आपकी key में एक अवधि है और उनमें से एक पैरामीटर इसके साथ आया था। key को एक टियर में एडिट करें, या पैरामीटर हटा दें।

**[`400 flex_unsupported_for_anthropic`](/hi/errors#flex_unsupported_for_anthropic)।** `options` में एक अवधि आपकी अपनी Anthropic key पर `claude-*` मॉडल तक पहुंच गई। [रेस](/hi/deadline-routing) जो एक Claude अवधि चलाती है, प्रबंधित key लेती है। अवधि हटा दें और key को डेडलाइन रखने दें, क्योंकि एक key अवधि इसके बजाय वापस आ जाती है।

**एक कॉन्फ़िग एडिट ने कुछ नहीं बदला।** एक बाद के कॉन्फ़िग स्रोत ने इसे ओवरराइड कर दिया। ऊपर दिए गए सर्च ऑर्डर की जांच करें, और प्रति रन एक फ़ाइल में ऑप्ट-इन करने के लिए `OPENCODE_CONFIG` को प्राथमिकता दें।

हमारे द्वारा लौटाए गए हर अस्वीकृति के लिए [errors](/hi/errors) देखें, और उन [एजेंट key](/hi/agent-keys) के लिए जो OpenCode के लिए विशिष्ट नहीं हैं। [OpenWork](/hi/openwork) और [OpenScience](/hi/openscience) समान प्रोवाइडर एंट्री पढ़ते हैं।