# Octolib 0.39.0: โมเดลที่เขียนประโยคไม่ได้แม้แต่ประโยคเดียว เพิ่งเข้ามาอยู่ในสแตก

> Octolib 0.39.0 เพิ่มการเรียกโมเดลชนิดที่สี่: evaluation. Jev ของ TypeSafe ตอบคำถามชนิด yes/no, choice และ score แบบไทป์แล้ว ด้วยความน่าจะเป็นที่คาลิเบรตมา ภายในเวลาไม่ถึงครึ่งวินาที — เรียกตรง, ผ่าน Cloudflare หรือผ่าน OctoHub ของคุณเอง พร้อมมีเดียผ่าน Cloudflare Workers AI, ONNX embeddings, Inception Mercury และ Tinker และ structured output ที่ตรวจความถูกต้องเพียงครั้งเดียว

# Octolib 0.39.0: โมเดลที่เขียนประโยคไม่ได้แม้แต่ประโยคเดียว เพิ่งเข้ามาอยู่ในสแตก

ตั้งแต่วันที่เราแยกมันออกมาจาก Octocode การเรียกโมเดลทุกครั้งในสแตกของเราเป็นอย่างใดอย่างหนึ่งในสามอย่าง สร้างข้อความ แปลงข้อความเป็นเวกเตอร์ จัดอันดับเวกเตอร์เทียบกับคำค้น [Octolib](https://github.com/muvon/octolib) — ไลบรารีภาษา Rust ใต้ [Octomind](https://octomind.run), [OctoHub](https://github.com/muvon/octohub), [Octocode](https://github.com/muvon/octocode) และ [Octobrain](https://github.com/muvon/octobrain) — มีโมดูลให้แต่ละอย่าง: `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 ซึ่งออกจากสถานะ stealth เมื่อวันที่ 15 กันยายน TypeSafe เรียกหมวดนี้ว่า **โมเดล System One** เราคิดว่ามันเป็น primitive ใหม่ที่น่าสนใจที่สุดที่เข้ามาในสแตก AI ปีนี้ และ Octolib 0.39.0 คือเดิมพันของเรา: สตริง `provider:model` เดียว สามเส้นทางเพื่อเข้าถึงมัน และการคิดต้นทุนแบบเดียวกับที่เราใช้กับทุกอย่างอื่น

นั่นคือพาดหัว ตัวรีลีสยังเปลี่ยน Cloudflare Workers AI ให้เป็นผู้ให้บริการมีเดียเต็มตัว เพิ่มแบ็กเอนด์ embedding แบบ ONNX ในเครื่อง นำผู้ให้บริการ LLM ใหม่เข้ามาสองราย และสุดท้ายทำให้ structured output ตรวจความถูกต้องเพียงครั้งเดียวพอดี ทุกอย่างนับจาก 0.36.1 อยู่ด้านล่าง

## ทำไมเอเจนต์ถึงต้องการโมเดลที่ตัดสินใจอย่างเดียว

ถ้าถอดเอเจนต์เขียนโค้ดจนเหลือแก่น จะมีโมเดลใหญ่หนึ่งตัวทำงานอยู่ รอบ ๆ มันมี control plane คอยตัดสินเรื่องเล็ก ๆ ที่มีขอบเขตชัดว่าโมเดลนั้นกำลังทำอะไร คำสั่ง shell นี้ควรทำงานไหม ในสี่สิบทักษะ มีอันไหนเข้ากับคำขอนี้บ้าง (ถ้ามี) ความทรงจำที่เรียกคืนมานี้เกี่ยวข้องจริงไหม เอเจนต์ต้องใช้ผลจากเครื่องมือขนาด 40 KB นี้ทั้งหมด หรือไม่ต้องใช้เลย

เอเจนต์เขียนโค้ดที่จริงจังทุกตัวมีชั้นที่สองนี้ ของเราคือ [supervisor ของ Octomind](https://octomind.run/docs/usage/14-supervisor) ของ Anthropic คือตัวจำแนก auto-mode ใน Claude Code และในทั้งสองกรณี โมเดลอเนกประสงค์เป็นผู้ตัดสินใจเหล่านั้นโดยปิดความสามารถหลักของมัน — การเขียนคำอธิบายที่มีเหตุผล — ไว้เฉพาะในการเรียกเหล่านี้ การเรียกไปกลับถึงโมเดล frontier หนึ่งรอบ ส่งใหม่ทุกการตัดสินใจ เพื่อได้กลับมาหนึ่งคำ

Jev ถูกสร้างมาเพื่อการตัดสินใจเหล่านั้นและไม่มีอย่างอื่น สาม primitive:

- **Noul** — คำถามใช่/ไม่ใช่ ตอบเป็นความน่าจะเป็นที่คำตอบคือใช่
- **Choice** — ตัวเลือกหนึ่งจากชุดที่คุณกำหนด พร้อมความน่าจะเป็นของทุกตัวเลือก และค่า confidence ที่บอกว่ากราฟการกระจายแหลมแค่ไหน
- **Score** — ตำแหน่งบนรูบริกแบบเรียงลำดับของระดับที่อธิบายด้วยคำ ซึ่งอาจตกอยู่ระหว่างระดับก็ได้

มันรับ state เข้ามาครั้งเดียวแล้วประเมินทุกคำถามเทียบกับ state นั้นใน pass ขนานเดียว คำถามข้อที่สิบจึงแทบฟรี มันถูกฝึกเพื่อความคาลิเบรชัน ไม่ใช่ความชอบ ดังนั้นคำตอบ 90% ควรจะถูกต้องราว 90% ของครั้งเมื่อทำนายจำนวนมาก และพื้นที่คำตอบปิดตายโดยโครงสร้าง: มันเลือกตัวเลือกผิดได้ แต่คิดค้นตัวเลือกใหม่ไม่ได้ จึงไม่มี JSON ให้ซ่อม ไม่มี enum ให้ fuzzy-match

เราเขียนเวอร์ชันยาว — มันคืออะไร พังตรงไหน คนเอาไปสร้างอะไรใน 72 ชั่วโมงแรก และการตัดสินใจระดับ control plane ข้อไหนในเอเจนต์ที่มันรับช่วงต่อได้ พร้อมตัวเลขสด ๆ — ไว้ที่บล็อก Octomind: **[Jev Explained: โมเดล System One ของ TypeSafe และการตัดสินใจภายในเอเจนต์ AI ทุกตัว](https://octomind.run/blog/jev-system-one-model-ai-agents)** โพสต์นี้ว่าด้วยตัวไลบรารี

## API

โมดูลชื่อ `evaluation` เปิดเป็นค่าเริ่มต้น และคอมไพล์เดี่ยวได้ถ้าคุณต้องการแค่นี้:

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

รูปทรงตามรอยส่วนที่เหลือของ Octolib หนึ่งไทป์คำขอ หนึ่ง helper ระดับสูง หนึ่งสตริง `provider:model`:

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

async fn triage() -> octolib::EvaluationResult<()> {
    // ต้องมี TYPESAFE_API_KEY; ใช้ "cloudflare:typesafe/jev" เพื่อคิดเงินเป็นเครดิต AI Gateway แทน
    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 หรืออาร์เรย์ คำตอบกลับมาแบบไทป์แล้วใต้ id เดียวกับคำถาม — `Answer::Noul`, `Answer::Choice` พร้อม map ความน่าจะเป็นและ confidence, `Answer::Score` พร้อม legend — คุณจึงแตกกิ่งด้วยตัวเลขใน Rust ไม่ใช่ด้วยข้อความที่ parse แล้ว

สามเส้นทางสู่โมเดลเดียวกัน:

| สตริงโมเดล | ไปถึง Jev ผ่าน | คีย์ |
| ------------------------- | ---------------------------------------------- | --------------------------------------------- |
| `typesafe:jev-latest`     | API ของ TypeSafe โดยตรง (early access)         | `TYPESAFE_API_KEY`                            |
| `cloudflare:typesafe/jev` | Cloudflare AI คิดเงินผ่านเครดิต AI Gateway     | `CLOUDFLARE_API_KEY`, `CLOUDFLARE_ACCOUNT_ID` |
| `octohub:jev`             | พร็อกซี OctoHub ของคุณเอง พร้อมต้นทุนที่ hub รายงาน | `OCTOHUB_API_KEY`, `OCTOHUB_API_URL`          |

รายละเอียดบางอย่างที่สำคัญก็ต่อเมื่อคุณใช้งานมันหนัก ๆ — ซึ่งเป็นส่วนที่เราใส่ใจ:

- **ที่นี่ retry ปลอดภัย** การประเมินไม่มี side effect การเล่นซ้ำจึงทำให้งานซ้ำซ้อนไม่ได้ ไคลเอนต์ retry เมื่อเจอ 429, 529 และ 5xx พร้อม backoff และเคารพ `Retry-After` โดยมีเพดาน 30 วินาที POST สำหรับ generation ที่อื่นใน Octolib จงใจ _ไม่_ เล่นซ้ำ; อันนี้เล่นซ้ำ
- **ต้นทุนคำนวณจากอัตราที่ประกาศไว้** $0.042 ต่อล้านโทเคนขาเข้า และไปลงที่ `usage.cost` เหมือนการเรียกอื่น ๆ ทุกครั้ง ผ่าน OctoHub ต้นทุนที่ hub รายงานจะถูกใช้แทน
- **ฟิลด์ `model` ในคำตอบรายงานโมเดลแบบระบุเวอร์ชันที่ตอบ** `jev-latest` ขยับเมื่อ TypeSafe ออกเวอร์ชันใหม่; ถ้าคุณจูน threshold ให้ log ค่านี้ไว้แล้ว pin
- **id โมเดลถูกตรวจก่อนคำขอออกจากเครื่อง** `openai:jev-latest` เป็นผู้ให้บริการที่ไม่สนับสนุน; `cloudflare:@cf/zai-org/glm-5.3` เป็นโมเดลแชต ไม่ใช่โมเดลประเมิน ทั้งคู่ fail ตอน construction ไม่ใช่ตอนส่งคำขอจริง

Jev มี context 32k และเอกสารของ TypeSafe เองบอกว่าความแม่นยำลดลงเมื่อ state เต็มไปด้วยเนื้อหาที่คำถามไม่ต้องการ ตัด state ให้สั้น ถามเยอะ ๆ; ส่งน้อย ๆ

## มันเสียบเข้าตรงไหน: Octomind และ OctoHub

เราไม่ได้เพิ่มโมดูลเข้า Octolib เพื่อความสนุก ทุกโมดูลมีอยู่เพราะผลิตภัณฑ์สักตัวต้องการมัน ส่วนโมดูลนี้มีผลิตภัณฑ์ต้องการถึงสองตัว

**supervisor ของ Octomind** ทำงานบน invariant เดิมอยู่แล้วว่าสัญญาณฟรีเป็นตัวกรองก่อนถึงโมเดล และการเรียกโมเดลนั้นหายาก วันนี้บน `main`, `[supervisor.evaluate]` เพิ่มชั้นที่สามแบบคาลิเบรตระหว่าง "ฟรี" กับ "frontier" ที่สามจุดเชื่อม: ตัวกรองความเกี่ยวข้องหลังการเรียกคืนความทรงจำ, roster Choice เมื่อกฎเปิดใช้ทักษะทุกข้อสละสิทธิ์, และตัวกลั่นกรองล่วงหน้าที่จะตัดสินว่าชุดเครื่องมือจำเป็นต้องปลุกโมเดล authorizer หรือไม่ แต่ละจุดเชื่อมคือสวิตช์หนึ่งตัว ปิดเป็นค่าเริ่มต้น หนึ่งความพยายามต่อการเรียก timeout ห้าวินาที ไม่ retry; หากล้มเหลวจะคงพฤติกรรมเดิมไว้สำหรับเทิร์นนั้น และกฎหนึ่งข้อที่เราจะวางไว้บนสุดของการใช้งาน Jev ทุกแบบ: **state ห้ามพกผลจากเครื่องมือหรือข้อความของ assistant เด็ดขาด** เพราะผู้ตรวจต้องไม่ได้อ่านสิ่งที่อาจกำลังโต้แย้งอยู่

**OctoHub** ได้ `POST /v1/evaluations` ตั้งค่า alias ครั้งเดียว ในพร็อกซีของคุณเอง ด้วยคีย์ของคุณเอง:

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

แล้วไคลเอนต์ทุกตัวในทุกภาษา — Python hook, TypeScript worker, shell script — เรียก `octohub:jev` และได้คำตอบแบบไทป์แล้วชุดเดียวกัน แถวต้นทุนต่อคำขอเดียวกัน และการระบุที่มาเดียวกับ chat completions ของมัน นั่นคือเหตุผลที่ `octohub` เป็นผู้ให้บริการ evaluation รายที่สามใน Octolib: ไลบรารีเรียกพร็อกซี พร็อกซีเรียก Octolib

ทั้งสองจะมากับรีลีสถัดไปของ Octomind และ OctoHub; ไลบรารีออกก่อนเพราะไลบรารีออกก่อนเสมอ

## Cloudflare Workers AI เป็นผู้ให้บริการมีเดียแล้ว

รอบก่อน สแตก `media` ของ Octolib ครอบคลุมภาพ วิดีโอ เสียงพูด และการถอดเสียง ผ่าน OpenRouter, Replicate, fal, ElevenLabs และ Runway 0.39.0 เพิ่ม **Cloudflare Workers AI** สำหรับภาพ เสียงพูด และการถอดเสียง ผ่าน endpoint แบบ synchronous `/ai/run` ตัวเดียวกับที่ผู้ให้บริการแชตใช้

โมเดลที่ลงทะเบียนไว้ พร้อมความสามารถ ตัวเลือก และราคาอ้างอิง:

- **ภาพ:** FLUX.1 schnell, FLUX.2 dev, Leonardo Lucid Origin และ Phoenix 1.0 คิดราคาต่อ output tile และ step
- **เสียงพูด:** Deepgram Aura 1 และ Aura 2 (อังกฤษและสเปน), MeloTTS คิดราคาต่อตัวอักษร
- **การถอดเสียง:** Whisper, Whisper large-v3-turbo, Deepgram Nova 3 คิดราคาต่อนาทีเสียง พร้อม segments, คำ, ภาษา และ metadata ที่ถูก parse เข้า transcript แบบไทป์แล้ว

แคตตาล็อกโหลดแบบ lazy และแคชหน้าไว้ มี fallback ไป metadata สำหรับโมเดลที่ Cloudflare ยังไม่ขึ้นรายการ ตรงไหนที่ upstream รายงานต้นทุนเป็น neuron ค่าเหล่านั้นถูกเก็บตามที่รายงาน แทนที่จะถูกแทนด้วยการประมาณระยะเวลา seed ของภาพส่งเฉพาะให้โมเดลที่รับมัน; ชนิดของเสียงพูดถูกเก็บไว้แทนที่จะถูกบังคับแปลง

ฝั่งแชตของผู้ให้บริการ Cloudflare ได้รับการปรับปรุงแบบเดียวกัน: เลือกและ normalize ระดับ reasoning ต่อโมเดล บังคับใช้ schema เฉพาะกับโมเดลรูปทรง OpenAI ที่เคารพมันจริง ๆ แก้ id โมเดลที่ทับซ้อนกันด้วยการจับคู่ที่ยาวที่สุด และ fallback ไปความสามารถอ้างอิงสำหรับโมเดลที่ไม่รู้จักแทนที่จะ fail

## อย่างอื่นทั้งหมดนับจาก 0.36.1

สิบรีลีสในสิบสองวัน เวอร์ชันย่อ

**ผู้ให้บริการ LLM ใหม่สองราย** [Inception Labs](https://www.inceptionlabs.ai/) ให้บริการตระกูล LLM แบบ diffusion ชื่อ Mercury: `inception:mercury-2.5` พร้อม Mercury 2 ข้างเคียง, JSON schema output และ tool calling [Tinker](https://thinkingmachines.ai/tinker/) จาก Thinking Machines ให้บริการตระกูล Inkling ของตน บวกโมเดล open-weight (Nemotron, GLM, Kimi, Qwen, GPT-OSS, DeepSeek) และ sampler checkpoints โดยจัดการ id โมเดลที่มีโคลอน และ resolve ชื่อสั้นอย่าง `tinker:inkling` ไปเป็น id ของ serverless inference ทั้งคู่มาพร้อมตัวอย่างที่รับสเปกโมเดลจาก command line

**ONNX embeddings ในเครื่อง** ผู้ให้บริการ embedding `onnx` ตัวใหม่โหลดกราฟและ tokenizer ของ HuggingFace เข้า ONNX Runtime — `onnx:<org>/<repo>` พร้อม `#path-to.onnx` แบบไม่บังคับสำหรับกราฟเฉพาะ — เลือกกราฟที่ quantize แล้วก่อน คำนึงถึง metadata ของ pooling และมิติแบบ static ทำ batch พร้อมติดตามการใช้โทเคน มันอยู่ข้าง ๆ FastEmbed และแบ็กเอนด์ HuggingFace บน Candle ในฐานะวิธีที่สามในการทำ embedding โดยไม่ต้องมี API key นี่คือ breaking change เพียงข้อเดียวของรอบนี้: `EmbeddingProviderType` ได้ variant `Onnx` เพิ่ม exhaustive match จึงต้องมี arm ใหม่

**Structured output ตรวจครั้งเดียว** flow เก่า retry การตรวจ schema ที่ไม่ผ่านได้ และรวม usage ข้ามความพยายาม นั่นหวังดีแต่ผิด: มันซ่อนพฤติกรรมของผู้ให้บริการไว้หลังลูป ตอนนี้มีการเรียก schema ขึ้น upstream ครั้งเดียวพอดี มีขั้น extraction และ validation รวมศูนย์ขั้นเดียว และ error จากการ parse หรือ validate กลับมาพร้อม log คำตอบที่มีปัญหาไว้ และไม่ retry tool call ของไคลเอนต์ยังคงอยู่หลังการ validate output ขั้นสุดท้าย สองผู้ให้บริการเลิกสัญญาเกินตัวในการเปลี่ยนแปลงเดียวกัน: Ollama และ Cloudflare ไม่อ้างการบังคับใช้ schema แบบรับประกันที่ตัวเองส่งมอบไม่ได้อีก และ OpenAI **fail แบบปิดตาย** เมื่อคำแนะนำ schema ถูกเมิน แทนที่จะคืนบางอย่างที่แค่ดูถูกต้อง

**ระดับ reasoning effort map ต่อผู้ให้บริการ** โมเดล GLM ของ Alibaba และ Z.ai ถูก map ไปยังระดับ effort ที่มันรองรับ; Fireworks คงระดับสูงสุดไว้สำหรับ GLM 5.2 Z.ai ตอนนี้รับข้อความแบบ preserved-thinking และเก็บเทิร์น assistant ที่เป็น thinking-only ไว้แทนที่จะทิ้ง

**รายชื่อโมเดลมีการเปลี่ยนแปลง** โมเดลที่ Cerebras ปลดระวางถูกแทนด้วย `qwen-3.8-27b` พร้อมรองรับวิดีโอและขีดจำกัดขาเข้า 128K route V4 ที่ DeepSeek ปลดระวางถูกแทนด้วย `deepseek-flash` ซึ่งถูกมองเป็น multimodal พร้อมแก้ราคา V4.1 Flash และเพิ่มบน Alibaba โมเดลที่ Hetzner ถอนถูกสลับเป็น Qwen แคชของ BytePlus และราคาบุคคลที่สามถูกรีเฟรช OctoHub ตอนนี้ probe มิติ embedding ตอน construction และแคชไว้ต่อ endpoint และโมเดล ซึ่งทำให้การสร้าง provider ของ OctoHub เป็น async — การเปลี่ยน API เล็ก ๆ ข้อที่สองที่ควรรู้ ตัว map ผู้ให้บริการตรวจ alias ของโมเดล คงตัวที่ quantize ไว้ และปฏิเสธโมเดลที่ไม่ได้ map ตอน construction แทนที่จะเป็นตอนคำขอแรก

**เล็กแต่จริง** รูปแบบเสียงของ fal ถูก map ไปค่าที่ fal รับ (MP3 และ PCM; รูปแบบที่ไม่สนับสนุนจะใช้ค่าเริ่มต้นของโมเดลแทน) เนื้อหาข้อความว่างได้รับอนุญาตอีกครั้ง `rustls` อยู่ที่ 0.23.45, `dirs` อยู่ที่ 7.0

## การอัปเกรด

- `cargo add octolib@0.39` หรือ bump เวอร์ชัน ทุก feature เปิดเป็นค่าเริ่มต้น; feature `evaluation` ตัวใหม่ไม่ลากของหนักอะไรเข้ามา
- ถ้าคุณ `match` บน `EmbeddingProviderType` ให้เพิ่ม arm `Onnx`
- ถ้าคุณสร้าง provider embedding ของ OctoHub ตรง ๆ ตอนนี้มันเป็น `async`
- ถ้าคุณพึ่งพาว่า structured output จะ retry การ validate ที่ไม่ผ่าน มันไม่ทำแล้ว error แนบสิ่งที่ผู้ให้บริการคืนมา; ตัดสินใจในโค้ดของคุณเอง
- ตั้ง `TYPESAFE_API_KEY` หรือ `CLOUDFLARE_API_KEY` บวก `CLOUDFLARE_ACCOUNT_ID` แล้วลองตัวอย่างด้านบน มันกินโทเคนขาเข้าไม่กี่ร้อย: ไม่ถึงสองในพันของเซนต์

## FAQ

**โมเดล evaluation คืออะไร?**
โมเดลที่ตอบคำถามแบบไทป์แล้วเกี่ยวกับ state ด้วยความน่าจะเป็นที่คาลิเบรตมา แทนที่จะสร้างข้อความ Jev ของ TypeSafe ซึ่งเป็นตัวแรก คืนความน่าจะเป็นใช่/ไม่ใช่ (Noul), ตัวเลือกหนึ่งจากชุด (Choice) หรือตำแหน่งบนรูบริก (Score) ภายใน 70 ถึง 500 ms มันเขียนโค้ดหรือร้อยแก้วไม่ได้ งานของมันคือการตัดสินใจรอบ ๆ LLM ของคุณ: routing, admission, การกรองความเกี่ยวข้อง, การเลือกทักษะ

**ต้องใช้บัญชี TypeSafe ไหม?**
ไม่ต้อง การเข้าถึงตรงอยู่ใน waitlist แต่ `cloudflare:typesafe/jev` ใช้ได้วันนี้ด้วยบัญชี Cloudflare และเครดิต AI Gateway ที่เติมไว้ และ `octohub:jev` ใช้ได้ผ่าน OctoHub ของคุณเอง โดยมีคีย์ตัวใดตัวหนึ่งอยู่เบื้องหลัง

**Octolib 0.39.0 ทำอะไรพังไหม?**
หนึ่ง variant ของ enum (`EmbeddingProviderType::Onnx`), หนึ่ง constructor กลายเป็น async (embeddings ของ OctoHub) และ structured output ไม่ retry ความล้มเหลวในการ validate อีก แชต มีเดีย reranking และสตริงโมเดลทุกตัวที่คุณใช้อยู่ไม่เปลี่ยนแปลง

**Jev อยู่ในตัว Octomind แล้วหรือยัง?**
เกต evaluation อยู่บน `main` ของ Octomind เบื้องหลัง `[supervisor.evaluate]` ปิดเป็นค่าเริ่มต้น และจะออกในรีลีสถัดไป รีลีส Octolib นี้คือฐานที่เกตเหล่านั้นสร้างอยู่

**ผลิตภัณฑ์ไหนบ้างที่รันบน Octolib?**
Octomind (ทุกการเรียกแชต embedding และเกต evaluation), OctoHub (แชต, embeddings, มีเดีย และ route ใหม่ `/v1/evaluations`), Octocode (แชต, embeddings, reranking) และ Octobrain (embeddings, reranking) เมื่อผู้ให้บริการเปลี่ยน API หรือราคา การแก้จะอยู่ที่เดียวและทุกผลิตภัณฑ์ได้รับพร้อมกัน

## ประเด็น

งานของ Octolib คือการทำให้โมเดลตัวถัดไปเป็นเพียงการแก้โค้ดบรรทัดเดียวสำหรับทุกอย่างที่เรา ship มาโดยตลอด ส่วนใหญ่นั่นหมายถึงผู้ให้บริการใหม่หรือราคาที่แก้แล้ว นาน ๆ ทีมันหมายถึงโมเดล _ชนิด_ ใหม่ และไลบรารีต้องตัดสินใจว่าจะจัดวางมันอย่างไร

โมเดล evaluation ลงตัวเป็นโมดูลที่สี่เพราะมันเป็นฟังก์ชันคนละอย่าง: ไม่ใช่ "เขียนคำตอบให้ฉัน" แต่คือ "นี่คือ state นี่คือคำถามของฉัน — บอกมาว่าคุณเชื่ออะไร และเชื่อแค่ไหน" เอเจนต์ต้องการ primitive นี้มาตั้งแต่ pre-tool hook ตัวแรก เราเลียนแบบมันด้วยโทเคนเดียวจากโมเดล reasoning มาตลอด ตอนนี้มันคือการเรียกแบบไทป์แล้ว คิดราคาอย่างซื่อตรง ห่างไปแค่สตริงเดียว

**[github.com/muvon/octolib](https://github.com/muvon/octolib)** · Apache-2.0 · [crates.io](https://crates.io/crates/octolib) · [บทความเจาะลึก Jev](https://octomind.run/blog/jev-system-one-model-ai-agents) บนบล็อก Octomind