> ## 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 कॉन्फ़िग बंडल आयात करके ओपनवर्क को FlexInference पर इंगित करें।

ओपनवर्क एक OpenCode बैकएंड को चलाता है, इसलिए आप जो फ़ाइल लिखते हैं वह एक OpenCode कॉन्फ़िग फ़ाइल होती है। बैकएंड उसमें से प्रोवाइडर एंट्री पढ़ता है।

ओपनवर्क आपको अपने UI में `start_within` सेट करने की कोई जगह नहीं देता है, इसलिए डेडलाइन key पर निर्भर करती है। पहले एक बनाएं: [एजेंट key](/hi/agent-keys) देखें।

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

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

<Accordion title="एजेंट सेटअप प्रॉम्प्ट कॉपी करें">
  ```text theme={null}
  Configure OpenWork to send its requests to FlexInference. OpenWork drives an OpenCode backend, so the file you write is an OpenCode config file that OpenWork imports into its profile.

  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.

  1. Create a directory named `config/` beside my OpenWork checkout and put `opencode.json` in it with this content:

  {
    "$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 }
          }
        }
      }
    }
  }

  2. Find the OpenCode binary OpenWork should drive and note its path.

  3. Give me the launch command, with the binary path filled in:

  OPENWORK_ELECTRON_USERDATA="$PWD/.openwork-flex-userdata" \
  OPENWORK_DATA_DIR="$PWD/.openwork-flex-data" \
  OPENWORK_DEV_OPENCODE_IMPORT_CONFIG_DIR="$PWD/config" \
  OPENWORK_OPENCODE_BIN=<path to the opencode binary> \
    pnpm dev

  4. Print this line for me to run in that same shell. Do not run it and do not ask for the value:

     export FLEXINFERENCE_API_KEY=<paste your key here>

     OpenWork passes its parent environment to the backend, which is how the value reaches the provider entry.

  5. Add `.openwork-flex-userdata/` and `.openwork-flex-data/` to `.gitignore` if this is a Git repository.

  Rules that matter, do not deviate:
  - OpenWork ignores a config file in the working directory. The bundle only reaches the backend through `OPENWORK_DEV_OPENCODE_IMPORT_CONFIG_DIR`.
  - The import only runs when `OPENWORK_DEV_MODE=1`, which `pnpm dev` sets. A production launch skips it entirely.
  - Reuse the same `OPENWORK_ELECTRON_USERDATA` and `OPENWORK_DATA_DIR` paths on every launch, or you start a fresh profile and lose session history. The copy overwrites on each launch but never deletes.
  - 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 the backend stays on its built-in default.

  Report what you created and give me the exact command to run.
  ```
</Accordion>

## ओपनवर्क कॉन्फ़िगर करें

1. एक `opencode.json` फ़ाइल को उसकी अपनी डायरेक्टरी में रखें। [OpenCode](/hi/opencode) से प्रोवाइडर एंट्री का उपयोग करें।
2. उस शेल में key को एक्सपोर्ट करें जो ओपनवर्क शुरू करता है।

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

3. इम्पोर्ट पाथ सेट करके ओपनवर्क लॉन्च करें।

```bash theme={null}
OPENWORK_ELECTRON_USERDATA="$PWD/.openwork-flex-userdata" \
OPENWORK_DATA_DIR="$PWD/.openwork-flex-data" \
OPENWORK_DEV_OPENCODE_IMPORT_CONFIG_DIR="$PWD/config" \
OPENWORK_OPENCODE_BIN=/path/to/opencode/binary \
  pnpm dev
```

ओपनवर्क बैकएंड को एक अलग प्रोफ़ाइल पर रखता है, इसलिए यह आपकी वर्किंग डायरेक्टरी में एक कॉन्फ़िग फ़ाइल को अनदेखा करता है। यह लॉन्च पर नामित डायरेक्टरी को प्रोफ़ाइल में कॉपी करता है, फिर उस कॉपी पर `OPENCODE_CONFIG_DIR` सेट करके बैकएंड शुरू करता है।

`pnpm dev` `OPENWORK_DEV_MODE=1` सेट करता है, जो इम्पोर्ट को चालू करता है।

ओपनवर्क पैरेंट एनवायरनमेंट को बैकएंड तक पहुंचाता है, जिससे `FLEXINFERENCE_API_KEY` प्रोवाइडर एंट्री तक पहुंचता है।

## स्कोप प्रोफ़ाइल से आता है, फ़ोल्डर से नहीं

ओपनवर्क आपकी वर्किंग डायरेक्टरी से कॉन्फ़िग नहीं पढ़ता है, इसलिए [OpenCode](/hi/opencode) द्वारा प्रदान किया गया ग्लोबल और प्रति-प्रोजेक्ट विभाजन यहां लागू नहीं होता है। स्कोप उस प्रोफ़ाइल से आता है जिसके विरुद्ध आप लॉन्च करते हैं।

| स्कोप        | इसे क्या सेट करता है                                | किस पर लागू होता है              |
| ------------ | --------------------------------------------------- | -------------------------------- |
| एक प्रोफ़ाइल | `OPENWORK_ELECTRON_USERDATA` और `OPENWORK_DATA_DIR` | उस प्रोफ़ाइल में हर सेशन पर      |
| बंडल         | `OPENWORK_DEV_OPENCODE_IMPORT_CONFIG_DIR`           | जो भी प्रोफ़ाइल इम्पोर्ट करती है |

आप जिस भी कॉन्फ़िगरेशन के बीच स्विच करना चाहते हैं, उसके लिए प्रोफ़ाइल पाथ का एक जोड़ा रखें। एक ही बंडल को दो प्रोफ़ाइल में इम्पोर्ट करने से आपको दो अलग-अलग सेटअप मिलते हैं, प्रत्येक का अपना सेशन हिस्ट्री होता है।

एक प्रोफ़ाइल बनाए रखने के लिए ऊपर दिए गए पाथ का पुन: उपयोग करें। एक नई प्रोफ़ाइल शुरू करने के लिए उन्हें बदलें।

## इम्पोर्ट हर लॉन्च पर कॉपी करता है और कभी डिलीट नहीं करता

कॉपी हर लॉन्च पर चलती है, और यह ओवरराइट करती है। बंडल को एडिट करें, उसी `OPENWORK_ELECTRON_USERDATA` और `OPENWORK_DATA_DIR` पाथ पर रीस्टार्ट करें, और बैकएंड नई फ़ाइल को पढ़ेगा।

यह कभी डिलीट नहीं करता है। बंडल से हटाई गई फ़ाइल प्रोफ़ाइल कॉपी में रहती है। इसे साफ़ करने के लिए दोनों वेरिएबल्स के लिए नए पाथ की आवश्यकता होती है, जिससे प्रोफ़ाइल फिर से शुरू होती है और उसका सेशन हिस्ट्री खो जाता है। ऐसा तभी करें जब कोई बची हुई फ़ाइल रास्ते में हो।

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

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

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

**इम्पोर्ट कभी नहीं चला।** `OPENWORK_DEV_MODE=1` ही इसे सक्षम बनाता है, और `pnpm dev` इसे सेट करता है। एक प्रोडक्शन लॉन्च इम्पोर्ट को छोड़ देता है।

**एक कॉन्फ़िग एडिट ने कुछ नहीं बदला।** कॉपी प्रति लॉन्च चलती है लेकिन केवल उस प्रोफ़ाइल पर जिसे वह दी गई थी। उसी `OPENWORK_ELECTRON_USERDATA` और `OPENWORK_DATA_DIR` पाथ पर रीस्टार्ट करें।

**आपके द्वारा हटाई गई फ़ाइल अभी भी लोड है।** कॉपी ओवरराइट करती है लेकिन कभी डिलीट नहीं करती। दोनों वेरिएबल्स के लिए नए पाथ के साथ एक नई प्रोफ़ाइल शुरू करें, सेशन हिस्ट्री के नुकसान को स्वीकार करते हुए।

**रिक्वेस्ट हम तक कभी नहीं पहुंचती।** बंडल में टॉप-लेवल `model` फ़ील्ड ही प्रोवाइडर का चयन करता है। इसके बिना बैकएंड अपने बिल्ट-इन डिफ़ॉल्ट पर रहता है।

**[`401 invalid_api_key`](/hi/errors#invalid_api_key)।** ओपनवर्क शुरू करने वाले शेल में `FLEXINFERENCE_API_KEY` अनसेट है। इसे वहीं एक्सपोर्ट करें, क्योंकि बैकएंड उस शेल के एनवायरनमेंट को इनहेरिट करता है।

हमारे द्वारा लौटाए गए हर अस्वीकृति के लिए [errors](/hi/errors) देखें, उन त्रुटियों के लिए [agent keys](/hi/agent-keys) देखें जो ओपनवर्क के लिए विशिष्ट नहीं हैं, और प्रोवाइडर एंट्री और प्रति-मॉडल डेडलाइन विकल्पों के लिए [OpenCode](/hi/opencode) देखें।