# Octolib 0.39.0: एक ऐसा मॉडल जो एक वाक्य भी नहीं लिख सकता, स्टैक में शामिल हो गया

> Octolib 0.39.0 एक चौथी तरह की मॉडल कॉल जोड़ता है: evaluation. TypeSafe का Jev टाइप्ड yes/no, choice और score सवालों के कैलिब्रेटेड प्रोबेबिलिटी वाले जवाब आधे सेकंड से कम में देता है — सीधे, Cloudflare के ज़रिए, या आपके अपने OctoHub के ज़रिए. साथ में Cloudflare Workers AI मीडिया, ONNX एम्बेडिंग्स, Inception Mercury और Tinker, और structured output जो सिर्फ़ एक बार वैलिडेट होता है.

# Octolib 0.39.0: एक ऐसा मॉडल जो एक वाक्य भी नहीं लिख सकता, स्टैक में शामिल हो गया

जिस दिन हमने इसे Octocode से निकाला था, तब से हमारे स्टैक में हर मॉडल कॉल तीन चीज़ों में से एक रही है. टेक्स्ट जनरेट करना. टेक्स्ट को वेक्टर में बदलना. किसी क्वेरी के मुकाबले वेक्टर्स को रैंक करना. [Octolib](https://github.com/muvon/octolib) — [Octomind](https://octomind.run), [OctoHub](https://github.com/muvon/octohub), [Octocode](https://github.com/muvon/octocode) और [Octobrain](https://github.com/muvon/octobrain) के नीचे चलने वाली Rust लाइब्रेरी — में हर एक के लिए एक मॉड्यूल था: `llm`, `embeddings`, `reranker`. फिर इसमें `media` जुड़ा.

आज इसमें चौथा जुड़ता है, और यह बाकियों जैसा नहीं है. `octolib::evaluation` एक ऐसे मॉडल से बात करता है जो **एक भी टोकन जनरेट नहीं कर सकता**. आप उसे एक state और टाइप्ड सवालों का सेट देते हैं, और वह प्रोबेबिलिटीज़ लौटाता है. हाँ या नहीं, N में से एक, किसी स्केल पर स्थिति. 70 से 500 मिलीसेकंड में. $0.042 प्रति मिलियन इनपुट टोकन पर, आउटपुट मुफ़्त — क्योंकि बिल करने लायक कोई आउटपुट है ही नहीं.

यह मॉडल [Jev](https://octomind.run/blog/jev-system-one-model-ai-agents) है, TypeSafe AI का, जो 15 सितंबर को स्टेल्थ से बाहर आया. TypeSafe इस कैटेगरी को **System One models** कहता है. हमें लगता है कि यह इस साल AI स्टैक में आया सबसे दिलचस्प नया प्रिमिटिव है, और Octolib 0.39.0 इस पर हमारा दांव है: एक `provider:model` स्ट्रिंग, उस तक पहुँचने के तीन तरीके, और वही कॉस्ट अकाउंटिंग जो हम बाकी हर चीज़ पर लागू करते हैं.

यही हेडलाइन है. इस रिलीज़ में Cloudflare Workers AI भी एक पूरा मीडिया प्रोवाइडर बन जाता है, एक लोकल ONNX एम्बेडिंग बैकएंड जुड़ता है, दो नए LLM प्रोवाइडर आते हैं, और आख़िरकार structured output ठीक एक बार वैलिडेट होता है. 0.36.1 के बाद का सब कुछ नीचे है.

## एजेंट को सिर्फ़ फ़ैसले लेने वाले मॉडल की ज़रूरत क्यों है

किसी कोडिंग एजेंट की परतें हटाते जाएँ तो अंदर एक बड़ा मॉडल काम करता दिखेगा. उसके इर्द-गिर्द एक कंट्रोल प्लेन बैठा होता है जो उस मॉडल की हरकतों पर छोटे, सीमित फ़ैसले लेता है. यह shell कमांड चले या नहीं? चालीस स्किल्स में से कौन-सी इस रिक्वेस्ट पर फ़िट बैठती है, अगर कोई बैठती भी है? यह रिकॉल की गई मेमोरी सचमुच प्रासंगिक है? एजेंट को इस 40 KB टूल रिज़ल्ट में से सब कुछ चाहिए, या कुछ भी नहीं?

हर गंभीर कोडिंग एजेंट के पास यह दूसरी परत होती है. हमारी है [Octomind का supervisor](https://octomind.run/docs/usage/14-supervisor). Anthropic का है Claude Code में auto-mode क्लासिफ़ायर. और दोनों ही मामलों में एक जनरल-पर्पस मॉडल ये फ़ैसले तब लेता है जब उसकी परिभाषित क्षमता — तर्कसंगत व्याख्या लिखना — इन्हीं कॉल्स के लिए बंद कर दी जाती है. एक frontier राउंड-ट्रिप, हर फ़ैसले पर दोबारा भेजा गया, सिर्फ़ एक शब्द पाने के लिए.

Jev उन्हीं फ़ैसलों के लिए बना है और किसी और चीज़ के लिए नहीं. तीन प्रिमिटिव:

- **Noul** — एक हाँ/नहीं सवाल, जिसका जवाब इस प्रोबेबिलिटी के रूप में आता है कि उत्तर हाँ है.
- **Choice** — आपके परिभाषित सेट में से एक विकल्प, हर विकल्प के लिए प्रोबेबिलिटी और एक कॉन्फ़िडेंस के साथ जो बताता है कि डिस्ट्रिब्यूशन कितनी केंद्रित है.
- **Score** — शब्दों में वर्णित लेवल्स की एक क्रमबद्ध रूब्रिक पर स्थिति, जो लेवल्स के बीच भी गिर सकती है.

यह state को एक ही बार पढ़ता है और एक ही पैरेलल पास में हर सवाल उसी पर आँकता है, इसलिए दसवाँ सवाल लगभग मुफ़्त है. यह कैलिब्रेशन के लिए ट्रेन किया गया है, प्रेफ़रेंस के लिए नहीं, इसलिए 90% वाला जवाब बहुत सारी भविष्यवाणियों में लगभग 90% बार सही होना चाहिए. और जवाबों की स्पेस निर्माण से ही बंद है: यह गलत विकल्प चुन सकता है, पर नया विकल्प गढ़ नहीं सकता — इसलिए न कोई JSON मरम्मत के लिए है, न कोई enum फ़ज़ी-मैच के लिए.

लंबा वर्ज़न — यह क्या है, कहाँ टूटता है, पहले 72 घंटों में लोगों ने इससे क्या बनाया, और एजेंट के अंदर कंट्रोल प्लेन के कौन-कौन से फ़ैसले यह संभाल सकता है, लाइव आँकड़ों के साथ — हमने Octomind ब्लॉग पर लिखा है: **[Jev Explained: TypeSafe का System One मॉडल और हर AI एजेंट के अंदर के फ़ैसले](https://octomind.run/blog/jev-system-one-model-ai-agents)**. यह पोस्ट लाइब्रेरी के बारे में है.

## API

मॉड्यूल का नाम `evaluation` है, डिफ़ॉल्ट रूप से चालू, और अगर आपको सिर्फ़ यही चाहिए तो यह अकेला कंपाइल हो जाता है:

```toml
octolib = { version = "0.39", default-features = false, features = ["evaluation"] }
```

शक्ल Octolib के बाकी हिस्सों जैसी ही है. एक रिक्वेस्ट टाइप, एक हाई-लेवल हेल्पर, एक `provider:model` स्ट्रिंग:

```rust
use octolib::{evaluate, Answer, EvaluationRequest, Question};

async fn triage() -> octolib::EvaluationResult<()> {
    // TYPESAFE_API_KEY चाहिए; AI Gateway क्रेडिट्स पर बिल कराने के लिए "cloudflare:typesafe/jev" इस्तेमाल करें.
    let request = EvaluationRequest::new("Help! My payouts have been failing for 3 days.")
        .with_question("is_urgent", Question::noul("Does this convey urgency?"))
        .with_question(
            "department",
            Question::choice(
                "Which team should handle this?",
                [("billing", "Payments, refunds"), ("technical", "Bugs, outages")],
            ),
        )
        .with_question(
            "frustration",
            Question::score("How frustrated is the customer?", ["Calm", "Frustrated", "Very angry"]),
        );
    let response = evaluate("typesafe:jev-latest", request).await?;
    if let Answer::Noul { noul } = response.answers["is_urgent"] {
        println!("urgent with p={noul:.2}, cost {:?}", response.usage.cost);
    }
    Ok(())
}
```

state एक स्ट्रिंग, JSON ऑब्जेक्ट या ऐरे हो सकता है. जवाब उन्हीं ids के नीचे टाइप्ड लौटते हैं जिनके नीचे सवाल थे — `Answer::Noul`, अपने प्रोबेबिलिटी मैप और कॉन्फ़िडेंस के साथ `Answer::Choice`, लेजेंड के साथ `Answer::Score` — इसलिए आप Rust में पार्स्ड टेक्स्ट पर नहीं, नंबरों पर ब्रांच लगाते हैं.

उसी मॉडल तक तीन रास्ते:

| मॉडल स्ट्रिंग | Jev तक किसके ज़रिए पहुँच होती है | कीज़ |
| ------------------------- | ---------------------------------------------- | --------------------------------------------- |
| `typesafe:jev-latest`     | सीधे TypeSafe का API (अर्ली एक्सेस) | `TYPESAFE_API_KEY`                            |
| `cloudflare:typesafe/jev` | Cloudflare AI, AI Gateway क्रेडिट्स से बिल | `CLOUDFLARE_API_KEY`, `CLOUDFLARE_ACCOUNT_ID` |
| `octohub:jev`             | आपका अपना OctoHub प्रॉक्सी, हब द्वारा रिपोर्ट की गई कॉस्ट के साथ | `OCTOHUB_API_KEY`, `OCTOHUB_API_URL`          |

कुछ बारीक़ियाँ जो तभी मायने रखती हैं जब आप इसे भारी लोड पर चलाते हैं — और वही हिस्सा हमें सबसे ज़्यादा दिलचस्प है:

- **यहाँ रीट्राई सुरक्षित है.** evaluation का कोई साइड इफ़ेक्ट नहीं होता, इसलिए दोबारा चलाने से काम डुप्लिकेट नहीं हो सकता. क्लाइंट 429, 529 और 5xx पर बैकऑफ़ के साथ रीट्राई करता है, और `Retry-After` को 30-सेकंड की सीमा तक मानता है. Octolib में बाकी जगह जनरेशन POST जान-बूझकर दोबारा _नहीं_ भेजे जाते; यह भेजा जाता है.
- **कॉस्ट प्रकाशित रेट से गिनी जाती है**, $0.042 प्रति मिलियन इनपुट टोकन, और बाकी हर कॉल की तरह `usage.cost` में आकर बैठती है. OctoHub के ज़रिए हब की रिपोर्ट की गई कॉस्ट ही मान्य होगी.
- **जवाब का `model` फ़ील्ड उस वर्ज़न्ड मॉडल को रिपोर्ट करता है जिसने जवाब दिया.** `jev-latest` तब खिसक जाता है जब TypeSafe नया वर्ज़न शिप करता है; अगर आप थ्रेशोल्ड ट्यून करते हैं तो इसे लॉग करें और पिन कर दें.
- **मॉडल ids रिक्वेस्ट निकलने से पहले वैलिडेट हो जाते हैं.** `openai:jev-latest` एक अनसपोर्टेड प्रोवाइडर है; `cloudflare:@cf/zai-org/glm-5.3` एक चैट मॉडल है, evaluation मॉडल नहीं. दोनों रिक्वेस्ट भेजते समय नहीं, कंस्ट्रक्शन के समय ही फ़ेल होते हैं.

Jev का कॉन्टेक्स्ट 32k है, और TypeSafe के अपने डॉक्स कहते हैं कि state में ऐसे मटेरियल भरने पर एक्युरेसी गिरती है जिसकी सवाल को ज़रूरत नहीं है. state को छाँटें. सवाल ज़्यादा पूछें; भेजें कम.

## यह कहाँ जुड़ता है: Octomind और OctoHub

हम Octolib में मॉड्यूल शौक़िया नहीं जोड़ते. हर मॉड्यूल इसलिए मौजूद है क्योंकि किसी प्रोडक्ट को उसकी ज़रूरत थी, और इसकी ज़रूरत दो बार पड़ी.

**Octomind का supervisor** पहले से उस इनवेरिएंट पर चलता है कि मुफ़्त सिग्नल मॉडल को गेट करते हैं और मॉडल कॉल्स दुर्लभ होती हैं. आज `main` पर, `[supervisor.evaluate]` "मुफ़्त" और "frontier" के बीच एक कैलिब्रेटेड तीसरी परत जोड़ता है, तीन जोड़ों पर: मेमोरी रिकॉल के बाद एक रिलेवेंस फ़िल्टर, एक roster Choice जब हर स्किल-एक्टिवेशन नियम ने हाथ खड़े कर दिए हों, और एक प्री-स्क्रीन जो तय करता है कि किसी टूल बैच को authorizer मॉडल को जगाने की ज़रूरत है या नहीं. हर जोड़ एक स्विच है, डिफ़ॉल्ट रूप से बंद. प्रति कॉल एक कोशिश, पाँच-सेकंड का टाइमआउट, कोई रीट्राई नहीं; कोई भी फ़ेलियर उस टर्न के लिए पुराना व्यवहार बरकरार रखता है. और एक नियम जिसे हम किसी भी Jev इंटीग्रेशन में सबसे ऊपर रखेंगे: **state में कभी टूल रिज़ल्ट या असिस्टेंट मैसेज नहीं जाते**, क्योंकि रिव्यूअर को वह चीज़ कभी नहीं पढ़नी चाहिए जो शायद उससे बहस कर रही हो.

**OctoHub** को `POST /v1/evaluations` मिलता है. एक बार alias कॉन्फ़िगर करें, अपने ही प्रॉक्सी में, अपनी ही कीज़ के साथ:

```toml
[evaluation_models]
"jev" = ["typesafe:jev-latest", "cloudflare:typesafe/jev"]
```

और हर भाषा का हर क्लाइंट — एक Python हुक, एक TypeScript वर्कर, एक shell स्क्रिप्ट — `octohub:jev` कॉल करता है और वही टाइप्ड जवाब, वही प्रति-रिक्वेस्ट कॉस्ट रो, और वही एट्रिब्यूशन पाता है जो उसके चैट कंप्लीशन्स को मिलता है. इसीलिए `octohub` Octolib का तीसरा evaluation प्रोवाइडर है: लाइब्रेरी प्रॉक्सी को कॉल करती है, प्रॉक्सी Octolib को.

दोनों अगली Octomind और OctoHub रिलीज़ में आएँगे; लाइब्रेरी पहले शिप हुई क्योंकि लाइब्रेरी हमेशा पहले शिप होती है.

## Cloudflare Workers AI अब एक मीडिया प्रोवाइडर है

पिछले दौर में Octolib का `media` स्टैक OpenRouter, Replicate, fal, ElevenLabs और Runway पर इमेज, वीडियो, स्पीच और ट्रांसक्रिप्शन कवर करता था. 0.39.0 इमेज, स्पीच और ट्रांसक्रिप्शन के लिए **Cloudflare Workers AI** जोड़ता है, उसी सिंक्रोनस `/ai/run` एंडपॉइंट के ज़रिए जो चैट प्रोवाइडर इस्तेमाल करता है.

रजिस्टर्ड मॉडल्स, उनकी क्षमताओं, विकल्पों और संदर्भ मूल्य निर्धारण के साथ:

- **इमेज:** FLUX.1 schnell, FLUX.2 dev, Leonardo Lucid Origin और Phoenix 1.0. प्रति आउटपुट टाइल और स्टेप मूल्य.
- **स्पीच:** Deepgram Aura 1 और Aura 2 (अंग्रेज़ी और स्पैनिश), MeloTTS. प्रति कैरेक्टर मूल्य.
- **ट्रांसक्रिप्शन:** Whisper, Whisper large-v3-turbo, Deepgram Nova 3. प्रति ऑडियो मिनट मूल्य, सेगमेंट्स, शब्दों, भाषाओं और मेटाडेटा के साथ जो टाइप्ड ट्रांसक्रिप्ट में पार्स होते हैं.

कैटलॉग लेज़ी-लोड होता है और पेज कैश करता है, उन मॉडल्स के लिए मेटाडेटा फ़ॉलबैक के साथ जिन्हें Cloudflare ने अभी लिस्ट नहीं किया. जहाँ अपस्ट्रीम न्यूरॉन कॉस्ट रिपोर्ट करता है, वे रिपोर्ट किए अनुसार ही संरक्षित रहती हैं, न कि ड्यूरेशन अनुमान से बदल दी जाती हैं. इमेज सीड्स सिर्फ़ उन्हीं मॉडल्स को जाते हैं जो उन्हें स्वीकार करते हैं; स्पीच टाइप्स को ज़बरदस्ती बदलने के बजाय संरक्षित रखा जाता है.

Cloudflare प्रोवाइडर के चैट पक्ष को भी वही ट्रीटमेंट मिला: यह प्रति मॉडल रीज़निंग लेवल्स चुनता और नॉर्मलाइज़ करता है, स्कीमा सिर्फ़ उन OpenAI-आकार वाले मॉडल्स पर लागू करता है जो सचमुच उनका पालन करते हैं, ओवरलैपिंग मॉडल ids को सबसे लंबे मैच से सुलझाता है, और अज्ञात मॉडल्स के लिए फ़ेल होने के बजाय संदर्भ क्षमताओं पर फ़ॉलबैक करता है.

## 0.36.1 के बाद बाकी सब कुछ

बारह दिनों में दस रिलीज़. संक्षिप्त वर्ज़न.

**दो नए LLM प्रोवाइडर.** [Inception Labs](https://www.inceptionlabs.ai/) Mercury डिफ़्यूज़न LLM परिवार उपलब्ध कराता है: `inception:mercury-2.5`, साथ में Mercury 2, JSON स्कीमा आउटपुट और टूल कॉलिंग. Thinking Machines का [Tinker](https://thinkingmachines.ai/tinker/) अपना Inkling परिवार उपलब्ध कराता है, साथ ही ओपन-वेट मॉडल्स (Nemotron, GLM, Kimi, Qwen, GPT-OSS, DeepSeek) और सैंपलर चेकपॉइंट्स — कोलन वाले मॉडल ids संभाले जाते हैं और `tinker:inkling` जैसे छोटे नाम serverless inference ids में रिज़ॉल्व होते हैं. दोनों के साथ ऐसे उदाहरण आते हैं जो मॉडल स्पेक कमांड लाइन से लेते हैं.

**ONNX एम्बेडिंग्स, लोकली.** एक नया `onnx` एम्बेडिंग प्रोवाइडर HuggingFace ग्राफ़ और टोकनाइज़र को ONNX Runtime में लोड करता है — `onnx:<org>/<repo>`, किसी ख़ास ग्राफ़ के लिए वैकल्पिक `#path-to.onnx` के साथ — क्वांटाइज़्ड ग्राफ़ को प्राथमिकता देता है, पूलिंग मेटाडेटा और स्टैटिक डायमेंशन्स मानता है, और टोकन यूसेज ट्रैक करते हुए बैचिंग करता है. यह FastEmbed और Candle-आधारित HuggingFace बैकएंड के बगल में, बिना API की के एम्बेड करने का तीसरा तरीका है. यह इस दौर का इकलौता ब्रेकिंग चेंज है: `EmbeddingProviderType` में `Onnx` वैरिएंट जुड़ा है, इसलिए exhaustive मैच को नई ब्रांच चाहिए.

**Structured output एक बार वैलिडेट होता है.** पुराना फ़्लो फ़ेल हुई स्कीमा वैलिडेशन को रीट्राई कर सकता था और कोशिशों भर का usage जोड़ सकता था. नीयत अच्छी थी, पर यह गलत था: यह प्रोवाइडर के व्यवहार को एक लूप के पीछे छिपाता था. अब ठीक एक अपस्ट्रीम स्कीमा कॉल होती है, एक केंद्रीकृत एक्सट्रैक्शन और वैलिडेशन स्टेप होता है, और पार्सिंग या वैलिडेशन एरर उस समस्या वाले रिस्पॉन्स को लॉग करते हुए बिना रीट्राई लौटता है. क्लाइंट टूल कॉल्स फ़ाइनल-आउटपुट वैलिडेशन के बाद भी बनी रहती हैं. उसी बदलाव में दो प्रोवाइडर्स ने ज़्यादा वादे करना बंद किया: Ollama और Cloudflare अब गारंटीड स्कीमा एनफ़ोर्समेंट का दावा नहीं करते जो वे दे नहीं सकते, और OpenAI स्कीमा गाइडेंस नज़रअंदाज़ होने पर **फ़ेल क्लोज़्ड** होता है, बजाय कुछ ऐसा लौटाने के जो सिर्फ़ सही दिखता है.

**रीज़निंग एफ़र्ट टियर प्रति प्रोवाइडर मैप होते हैं.** Alibaba और Z.ai के GLM मॉडल्स उन एफ़र्ट टियर पर मैप किए जाते हैं जिन्हें वे सपोर्ट करते हैं; Fireworks GLM 5.2 के लिए अधिकतम टियर संरक्षित रखता है. Z.ai अब preserved-thinking मैसेज स्वीकार करता है और thinking-only असिस्टेंट टर्न को गिराने के बजाय रखता है.

**रोस्टर बदला.** Cerebras के रिटायर्ड मॉडल्स की जगह `qwen-3.8-27b` आ गया है, वीडियो सपोर्ट और 128K इनपुट लिमिट के साथ. DeepSeek के रिटायर्ड V4 रूट्स की जगह `deepseek-flash` है, जिसे मल्टीमॉडल माना जाता है; V4.1 Flash का मूल्य निर्धारण सुधारा गया और Alibaba पर जोड़ा गया. Hetzner के वापस लिए गए मॉडल्स की जगह Qwen आ गया. BytePlus कैश और थर्ड-पार्टी प्राइसिंग रिफ़्रेश हुए. OctoHub अब कंस्ट्रक्शन के समय एम्बेडिंग डायमेंशन्स प्रोब करता है और उन्हें प्रति एंडपॉइंट व मॉडल कैश करता है, जिससे OctoHub प्रोवाइडर कंस्ट्रक्शन async हो गया — दूसरा छोटा API बदलाव जो जानने लायक़ है. प्रोवाइडर मैपर मॉडल aliases वैलिडेट करता है, क्वांटाइज़्ड वाले संरक्षित रखता है, और अनमैप्ड मॉडल्स को पहली रिक्वेस्ट पर नहीं, कंस्ट्रक्शन पर ही रिजेक्ट करता है.

**छोटे मगर असली बदलाव.** fal ऑडियो फ़ॉर्मैट्स उन मानों पर मैप होते हैं जो fal स्वीकार करता है (MP3 और PCM; अनसपोर्टेड फ़ॉर्मैट्स मॉडल डिफ़ॉल्ट पर चले जाते हैं). खाली मैसेज कंटेंट फिर से अनुमत है. `rustls` 0.23.45 पर है, `dirs` 7.0 पर.

## अपग्रेड करना

- `cargo add octolib@0.39` या वर्ज़न बढ़ा दें. हर फ़ीचर डिफ़ॉल्ट रूप से चालू है; नया `evaluation` फ़ीचर कुछ भारी नहीं खींचता.
- अगर आप `EmbeddingProviderType` पर `match` करते हैं, तो `Onnx` ब्रांच जोड़ें.
- अगर आप OctoHub एम्बेडिंग प्रोवाइडर को सीधे कंस्ट्रक्ट करते हैं, तो वह अब `async` है.
- अगर आप इस पर निर्भर थे कि structured output फ़ेल वैलिडेशन को रीट्राई करता है, तो अब नहीं करता. एरर में प्रोवाइडर का लौटाया हुआ कंटेंट होता है; फ़ैसला अपने कोड में लें.
- `TYPESAFE_API_KEY`, या `CLOUDFLARE_API_KEY` और `CLOUDFLARE_ACCOUNT_ID` सेट करें, और ऊपर वाला उदाहरण आज़माएँ. इसमें कुछ सौ इनपुट टोकन लगते हैं: एक सेंट के दो हज़ारवें हिस्से से भी कम.

## FAQ

**Evaluation मॉडल क्या है?**
एक ऐसा मॉडल जो टेक्स्ट जनरेट करने के बजाय किसी state पर टाइप्ड सवालों के कैलिब्रेटेड प्रोबेबिलिटी वाले जवाब देता है. TypeSafe का Jev, पहला ऐसा मॉडल, हाँ/नहीं प्रोबेबिलिटी (Noul), सेट में से एक विकल्प (Choice), या रूब्रिक पर स्थिति (Score) लौटाता है, 70 से 500 ms में. यह कोड या गद्य नहीं लिख सकता. इसका काम आपके LLM के इर्द-गिर्द के फ़ैसले हैं: रूटिंग, एडमिशन, रिलेवेंस फ़िल्टरिंग, स्किल सिलेक्शन.

**इसे इस्तेमाल करने के लिए TypeSafe अकाउंट चाहिए?**
नहीं. डायरेक्ट एक्सेस वेटलिस्ट पर है, पर `cloudflare:typesafe/jev` आज ही काम करता है — Cloudflare अकाउंट और लोड किए गए AI Gateway क्रेडिट्स के साथ — और `octohub:jev` आपके अपने OctoHub के ज़रिए काम करता है, पीछे किसी भी की के साथ.

**क्या Octolib 0.39.0 कुछ तोड़ता है?**
एक enum वैरिएंट (`EmbeddingProviderType::Onnx`), एक कंस्ट्रक्टर async हुआ (OctoHub एम्बेडिंग्स), और structured output अब वैलिडेशन फ़ेलियर रीट्राई नहीं करता. चैट, मीडिया, रीरैंकिंग और हर वह मॉडल स्ट्रिंग जो आप पहले से इस्तेमाल करते हैं, अपरिवर्तित हैं.

**क्या Jev पहले से Octomind के अंदर है?**
Evaluation गेट्स Octomind की `main` ब्रांच पर `[supervisor.evaluate]` के पीछे हैं, डिफ़ॉल्ट रूप से बंद, और अगली रिलीज़ में शिप होंगे. यह Octolib रिलीज़ ही वह आधार है जिस पर वे बने हैं.

**कौन-से प्रोडक्ट्स Octolib पर चलते हैं?**
Octomind (हर चैट कॉल, एम्बेडिंग और evaluation गेट), OctoHub (चैट, एम्बेडिंग्स, मीडिया और नया `/v1/evaluations` रूट), Octocode (चैट, एम्बेडिंग्स, रीरैंकिंग) और Octobrain (एम्बेडिंग्स, रीरैंकिंग). जब कोई प्रोवाइडर अपना API या मूल्य निर्धारण बदलता है, तो फ़िक्स एक जगह रहता है और हर प्रोडक्ट को मिल जाता है.

## असल बात

Octolib का काम हमेशा यही रहा है कि अगला मॉडल हमारे शिप किए हर प्रोडक्ट के लिए एक-लाइन का बदलाव बन जाए. ज़्यादातर बार इसका मतलब नया प्रोवाइडर या सुधरी हुई कीमत होता है. कभी-कभी इसका मतलब मॉडल की एक नई _क़िस्म_ होता है, और लाइब्रेरी को तय करना पड़ता है कि वह कैसे फ़िट होगी.

Evaluation मॉडल्स चौथे मॉड्यूल के रूप में फ़िट होते हैं क्योंकि वे एक अलग फ़ंक्शन हैं: "मुझे जवाब लिखकर दो" नहीं, बल्कि "यह state है, ये मेरे सवाल हैं — बताओ तुम क्या मानते हो और कितनी मज़बूती से." एजेंट्स को पहले pre-tool हुक से ही इस प्रिमिटिव की ज़रूरत थी. हम अब तक किसी रीज़निंग मॉडल के एक टोकन से इसका जुगाड़ चला रहे थे. अब यह एक टाइप्ड कॉल है, ईमानदार प्राइसिंग के साथ, एक स्ट्रिंग की दूरी पर.

**[github.com/muvon/octolib](https://github.com/muvon/octolib)** · Apache-2.0 · [crates.io](https://crates.io/crates/octolib) · Octomind ब्लॉग पर [Jev की गहरी पड़ताल](https://octomind.run/blog/jev-system-one-model-ai-agents).