# OmniRoute Auto-Combo Engine (සිංහල) 🌐 **Languages:** 🇺🇸 [English](../../../../routing/AUTO-COMBO.md) · 🇪🇹 [am](../../../am/docs/routing/AUTO-COMBO.md) · 🇸🇦 [ar](../../../ar/docs/routing/AUTO-COMBO.md) · 🇦🇿 [az](../../../az/docs/routing/AUTO-COMBO.md) · 🇧🇬 [bg](../../../bg/docs/routing/AUTO-COMBO.md) · 🇧🇩 [bn](../../../bn/docs/routing/AUTO-COMBO.md) · 🇧🇦 [bs](../../../bs/docs/routing/AUTO-COMBO.md) · 🇨🇿 [cs](../../../cs/docs/routing/AUTO-COMBO.md) · 🇩🇰 [da](../../../da/docs/routing/AUTO-COMBO.md) · 🇩🇪 [de](../../../de/docs/routing/AUTO-COMBO.md) · 🇬🇷 [el](../../../el/docs/routing/AUTO-COMBO.md) · 🇪🇸 [es](../../../es/docs/routing/AUTO-COMBO.md) · 🇪🇪 [et](../../../et/docs/routing/AUTO-COMBO.md) · 🇮🇷 [fa](../../../fa/docs/routing/AUTO-COMBO.md) · 🇫🇮 [fi](../../../fi/docs/routing/AUTO-COMBO.md) · 🇫🇷 [fr](../../../fr/docs/routing/AUTO-COMBO.md) · 🇮🇪 [ga](../../../ga/docs/routing/AUTO-COMBO.md) · 🇮🇳 [gu](../../../gu/docs/routing/AUTO-COMBO.md) · 🇳🇬 [ha](../../../ha/docs/routing/AUTO-COMBO.md) · 🇮🇱 [he](../../../he/docs/routing/AUTO-COMBO.md) · 🇮🇳 [hi](../../../hi/docs/routing/AUTO-COMBO.md) · 🇭🇷 [hr](../../../hr/docs/routing/AUTO-COMBO.md) · 🇭🇺 [hu](../../../hu/docs/routing/AUTO-COMBO.md) · 🇦🇲 [hy](../../../hy/docs/routing/AUTO-COMBO.md) · 🇮🇩 [id](../../../id/docs/routing/AUTO-COMBO.md) · 🇳🇬 [ig](../../../ig/docs/routing/AUTO-COMBO.md) · 🇮🇹 [it](../../../it/docs/routing/AUTO-COMBO.md) · 🇯🇵 [ja](../../../ja/docs/routing/AUTO-COMBO.md) · 🇬🇪 [ka](../../../ka/docs/routing/AUTO-COMBO.md) · 🇰🇭 [km](../../../km/docs/routing/AUTO-COMBO.md) · 🇮🇳 [kn](../../../kn/docs/routing/AUTO-COMBO.md) · 🇰🇷 [ko](../../../ko/docs/routing/AUTO-COMBO.md) · 🇱🇹 [lt](../../../lt/docs/routing/AUTO-COMBO.md) · 🇱🇻 [lv](../../../lv/docs/routing/AUTO-COMBO.md) · 🇮🇳 [ml](../../../ml/docs/routing/AUTO-COMBO.md) · 🇮🇳 [mr](../../../mr/docs/routing/AUTO-COMBO.md) · 🇲🇾 [ms](../../../ms/docs/routing/AUTO-COMBO.md) · 🇲🇹 [mt](../../../mt/docs/routing/AUTO-COMBO.md) · 🇲🇲 [my](../../../my/docs/routing/AUTO-COMBO.md) · 🇳🇵 [ne](../../../ne/docs/routing/AUTO-COMBO.md) · 🇳🇱 [nl](../../../nl/docs/routing/AUTO-COMBO.md) · 🇳🇴 [no](../../../no/docs/routing/AUTO-COMBO.md) · 🇮🇳 [or](../../../or/docs/routing/AUTO-COMBO.md) · 🇮🇳 [pa](../../../pa/docs/routing/AUTO-COMBO.md) · 🇵🇭 [phi](../../../phi/docs/routing/AUTO-COMBO.md) · 🇵🇱 [pl](../../../pl/docs/routing/AUTO-COMBO.md) · 🇵🇹 [pt](../../../pt/docs/routing/AUTO-COMBO.md) · 🇧🇷 [pt-BR](../../../pt-BR/docs/routing/AUTO-COMBO.md) · 🇷🇴 [ro](../../../ro/docs/routing/AUTO-COMBO.md) · 🇷🇺 [ru](../../../ru/docs/routing/AUTO-COMBO.md) · 🇸🇰 [sk](../../../sk/docs/routing/AUTO-COMBO.md) · 🇸🇮 [sl](../../../sl/docs/routing/AUTO-COMBO.md) · 🇷🇸 [sr](../../../sr/docs/routing/AUTO-COMBO.md) · 🇸🇪 [sv](../../../sv/docs/routing/AUTO-COMBO.md) · 🇰🇪 [sw](../../../sw/docs/routing/AUTO-COMBO.md) · 🇮🇳 [ta](../../../ta/docs/routing/AUTO-COMBO.md) · 🇮🇳 [te](../../../te/docs/routing/AUTO-COMBO.md) · 🇹🇭 [th](../../../th/docs/routing/AUTO-COMBO.md) · 🇹🇷 [tr](../../../tr/docs/routing/AUTO-COMBO.md) · 🇺🇦 [uk-UA](../../../uk-UA/docs/routing/AUTO-COMBO.md) · 🇵🇰 [ur](../../../ur/docs/routing/AUTO-COMBO.md) · 🇺🇿 [uz](../../../uz/docs/routing/AUTO-COMBO.md) · 🇻🇳 [vi](../../../vi/docs/routing/AUTO-COMBO.md) · 🇳🇬 [yo](../../../yo/docs/routing/AUTO-COMBO.md) · 🇨🇳 [zh-CN](../../../zh-CN/docs/routing/AUTO-COMBO.md) · 🇹🇼 [zh-TW](../../../zh-TW/docs/routing/AUTO-COMBO.md) --- > **පරිශීලකයින් සඳහා**: ඉක්මන් ආරම්භයක් සොයනවාද? සරල පැහැදිලි කිරීම් සහ උදාහරණ සඳහා [ස්වයංක්රීය-සංයෝජන පරිශීලක මාර්ගෝපදේශය](../getting-started/AUTO-COMBO-GUIDE.md) බලන්න. > අනුවර්තී ලකුණුකරණය + වින්යාස කිරීමකින් තොර ස්වයංක්රීය මාර්ගගත කිරීම සහිත ස්වයං-කළමනාකරණ ආකෘති දාම ## ශුන්ය-වින්යාස ස්වයංක්රීය මාර්ගගත කිරීම (`auto/` උපසර්ගය) > **නව:** combo සෑදීම අවශ්ය නොවේ. ඕනෑම client එකක සෘජුවම `auto/` උපසර්ගය භාවිත කරන්න. ### ඉක්මන් උදාහරණ | Model ID | ප්රභේදය | හැසිරීම | | -------------- | ------- | ---------------------------------------------------------------------------------- | | `auto` | පෙරනිමි | සම්බන්ධිත සියලු providers, LKGP උපායමාර්ගය, සමතුලිත weights | | `auto/coding` | coding | ගුණාත්මකභාවයට ප්රමුඛත්වය දෙන weights, code ජනනය සඳහා සුදුසුය | | `auto/fast` | fast | අඩු-ප්රමාද weighted තේරීම | | `auto/cheap` | cheap | පිරිවැය-ප්රශස්ත කළ මාර්ගගත කිරීම (අඩුම පිරිවැය පළමුව) | | `auto/offline` | offline | ඉහළම quota ලබාගත හැකි providers වෙත ප්රමුඛත්වය දෙයි | | `auto/smart` | smart | වඩා හොඳ model සොයාගැනීම සඳහා ගුණාත්මකභාවයට ප්රමුඛත්වය + ඉහළ exploration rate (10%) | | `auto/lkgp` | lkgp | පැහැදිලි LKGP (පෙරනිමි `auto` හා සමානයි) | | `auto/chaos` | chaos | සමාන්තර fan-out, එක් provider එකකට එක් model එකක් (fault injection නොවේ) | ### ප්රවර්ගය × ස්තර සංයෝජනය (`auto/:`) OpenRouter-ශෛලියේ suffix මඟින් **කුමන ආකාරයේ මාර්ගයක්ද** (category) යන්න **එය ප්රශස්ත කරන්නේ කෙසේද** (tier) යන්නෙන් වෙන් කරයි, එබැවින් ඒවා නිදහසේ සංයෝජනය කළ හැකිය (#4235 Phase B, `open-sse/services/autoCombo/suffixComposition.ts`): - **ප්රවර්ග** (හැකියාව අනුව candidate pool එක පෙරහන් කරන්න): `coding` · `reasoning` · `vision` · `chat` · `multimodal`. `vision`/`multimodal` මඟින් vision හැකියාව ඇති models තබා ගනී; `reasoning` මඟින් reasoning/thinking models තබා ගනී. - **ස්තර** (scoring weights / pool filter එක තෝරන්න): `fast` (ඉක්මනින් නිකුත් කිරීම) · `cheap` (`floor` යන alias එක, පිරිවැය ඉතිරි කිරීම) · `reliable` (circuit-breaker සෞඛ්යය + latency ස්ථායීතාව) · `free` / `pro` (`classifyTier` හරහා model tier අනුව pool එක පෙරහන් කිරීම — free-tier එදිරිව premium). | උදාහරණය | විසඳෙන්නේ | | ---------------------- | ----------------------------------------------------------------- | | `auto/coding:fast` | coding pool, අඩු-ප්රමාද weights | | `auto/coding:cheap` | coding pool, පිරිවැය-ප්රශස්ත කළ (`auto/coding:floor` යන alias එක) | | `auto/reasoning:pro` | reasoning/thinking models පමණි, premium tier | | `auto/vision` | vision හැකියාව ඇති models (tier එකක් නැත → සමතුලිත weights) | | `auto/multimodal:free` | multimodal හැකියාව ඇති models, free tier පමණි | වලංගු ඕනෑම `auto/[:]` එකක් ඉල්ලුම අනුව resolve වේ; තෝරා සැකසූ subset එකක් `/v1/models` සහ dashboard එකෙහි ප්රචාරණය කෙරේ (`open-sse/services/autoCombo/builtinCatalog.ts` හි `AUTO_SUFFIX_VARIANTS`). Filtering **fail-open** වේ — constraint එකක් කිසිදු සම්බන්ධිත model එකකට නොගැළපෙන්නේ නම්, routing කිසි විටෙකත් බිඳ නොවැටෙන ලෙස සම්පූර්ණ pool එක භාවිත කෙරේ. මූලික scorer එක (`combo.ts`) වෙනස් කර නැත; category/tier filter එක `buildAutoCandidates` තුළ යොදනු ලැබේ. > **සජීවී model බුද්ධිය:** `ARENA_ELO_SYNC_ENABLED` flag එක ක්රියාත්මක විට, auto-routing යෝග්යතාව සජීවී **Arena ELO** ශ්රේණිගත කිරීම් + **models.dev** tier දත්ත මඟින් දැනුවත් කෙරේ (එසේ නොමැති විට static fitness map එක වෙත ආපසු යයි). **භාවිත කරන ආකාරය:** ```bash # OpenAI ආකෘතියට සහාය දක්වන ඕනෑම IDE හෝ CLI මෙවලමක් Base URL: http://localhost:20128/v1 API Key: # ඔබේ code/config තුළ model එක මෙසේ සකසන්න: model: "auto" # සමතුලිත පෙරනිමිය model: "auto/coding" # coding කාර්ය සඳහා වඩාත් සුදුසුයි model: "auto/fast" # ලබාගත හැකි වේගවත්ම එක model: "auto/cheap" # token එකකට ලාභම එක ``` **සිදුවන්නේ කුමක්ද:** 1. OmniRoute විසින් `src/sse/handlers/chat.ts` තුළ `auto/` උපසර්ගය හඳුනා ගනී 2. database එකෙන් සියලු **සක්රිය provider connections** විමසයි 3. වලංගු credentials (API key හෝ OAuth token) ඇති ඒවාට පෙරහන් කරයි 4. connection එකකට model එක තීරණය කරයි (`connection.defaultModel` හෝ providerගේ පළමු model එක) 5. memory තුළ **virtual combo** එකක් ගොඩනඟයි (DB එකෙහි ගබඩා නොකෙරේ) 6. තෝරාගත් variant එකේ weight profile + LKGP උපායමාර්ගය භාවිතයෙන් මාර්ගගත කරයි **ප්රධාන ගුණාංග:** - ✅ **සැමවිටම ක්රියාත්මකයි:** toggle එකක්, combo සෑදීමක් හෝ configuration එකක් අවශ්ය නොවේ - ✅ **ගතිකයි:** දැනට සම්බන්ධිත providers ස්වයංක්රීයව පිළිබිඹු කරයි - ✅ **Session stickiness:** LKGP මඟින් අවසන් වරට සාර්ථක වූ provider වෙත ප්රමුඛත්වය දීම සහතික කරයි - ✅ **බහු-account පිළිබඳ දැනුවත්:** එක් එක් provider connection එක වෙනම candidate එකක් බවට පත්වේ - ✅ **DB ලිවීම් නැත:** Virtual combo එක පවතින්නේ request එක සඳහා පමණි, persistence overhead එක ශුන්යයි ### එක් key එකකට candidate පාලනය (#7819, Level 1+2) `GET /v1/auto-combo/{channel}/candidates` (`{channel}` = `auto/` පසු ඇති suffix එක, හෝ මූලික channel එක සඳහා literal `auto`) යනු පවතින resilience reads නැවත භාවිත කරමින් (`state` යන raw breaker අගය කිසිවිටෙක නොගෙන), සජීවී reachability තොරතුරු සමඟ `auto/*` channel එකක වත්මන් candidate pool එක ලැයිස්තුගත කරන **read-only** endpoint එකකි: - provider circuit breaker — `getCircuitBreaker(provider).getStatus()` / `.canExecute()` - connection cooldown — resolve කළ `provider_connections` row එකෙහි `rateLimitedUntil` / `testStatus` - model lockout — `isModelLocked(provider, connectionId, model)` සෑම candidate එකක්ම මෙම API key එකේ `excluded` flag එකද දරයි. Exclusions එක් එක් API key එක අනුව (`auto_candidate_overrides` table එක, migration `128`) ගබඩා කෙරේ — OmniRoute යනු `users` table එකක් නොමැති single-tenant පද්ධතියක් බැවින් `apiKeyId` යනු සැබෑ එක් එක් caller සඳහා ආසන්නතම identity එකයි — ඒවා pure, unit-tested `filterExcludedCandidates()` (`open-sse/services/autoCombo/candidateOverrides.ts`) හරහා `open-sse/services/autoCombo/virtualFactory.ts` හි candidate-pool chokepoint එකේදී බලාත්මක කෙරේ. Filter එක **fail-open** වේ: සකසා නොමැති apiKeyId/channel එකක් හෝ DB lookup අසාර්ථක වීමක් යන දෙකම pool එක පෙරහන් නොකර තබයි; එබැවින් overrides configure කර නොමැති operator කෙනෙකුට, මෙම විශේෂාංගයට පෙර තිබූ routing එක byte මට්ටමින් සම්පූර්ණයෙන් සමානව පෙනේ. **පසු විපරම් ගැටලුවකට කල් දමන ලදී:** එක් එක් අපේක්ෂකයා සඳහා බර + පැහැදිලි අනුපිළිවෙළ (Level 3 — දැනට පවතින බරිත/ප්රමුඛතා උපාය මාර්ග වෙත යොමු වේ) සහ එක් එක් `auto/*` නාලිකාව සඳහා නිශ්චිත `combo.ts` උපාය මාර්ගයක් ඇණ ගැසීම (Level 4). තනි-කුලීකරු ආකෘතිය සැලකිල්ලට ගනිමින්, අභිබවා යෑම් එක් එක් API යතුරකට වෙන්ව පැවතිය යුතුද නැතහොත් ගෝලීය විය යුතුද යන විවෘත ප්රශ්නය සඳහා #7819 සැලැස්ම බලන්න. **තිරය පිටුපස:** ```txt ඉල්ලීම: { model: "auto/coding" } ↓ src/sse/handlers/chat.ts උපසර්ගය හඳුනා ගනී ↓ createVirtualAutoCombo('coding') → සක්රිය සම්බන්ධතා වෙතින් candidatePool ↓ handleComboChat (සුරැකි combos භාවිත කරන එම එන්ජිම) ↓ ස්වයංක්රීය ලකුණු කිරීම එක් එක් ඉල්ලීම සඳහා හොඳම සැපයුම්කරු/ආකෘතිය තෝරයි ``` **ක්රියාත්මක කිරීමේ ගොනු:** | ගොනුව | අරමුණ | | --------------------------------------------------------- | ------------------------------------------------ | | `open-sse/services/autoCombo/autoPrefix.ts` | උපසර්ග විග්රහකය (`parseAutoPrefix`) | | `open-sse/services/autoCombo/virtualFactory.ts` | අතථ්ය `AutoComboConfig` වස්තු නිර්මාණය කරයි | | `open-sse/services/autoCombo/providerRegistryAccessor.ts` | සැපයුම්කරු රෙජිස්ට්රිය අනුකරණය සඳහා පරීක්ෂණ හුකය | | `src/sse/handlers/chat.ts` | ඒකාබද්ධ කිරීම: auto උපසර්ග කෙටි-පරිපථය | | `src/shared/constants/providers.ts` | `SYSTEM_PROVIDERS.auto` පද්ධති ඇතුළත් කිරීම | ## සැබෑ Model Id එකකට ගැළපෙන Combo නම් හිස් model id එකකට සමාන `name` එකක් ඇති combo එකක් (උදා. `gpt-5.5` නමින් ඇති combo එකක්) යනු දෝෂයක් නොව, **හිතාමතාම සපයන සහය දක්වන රටාවකි**: එය [#6940](https://github.com/diegosouzapw/OmniRoute/issues/6940) හි ලේඛනගත කර ඇති එක් එක් model id සඳහා provider fallback යාන්ත්රණයයි. හිස්-model-id විසඳීමට පෙර combo විසඳීම පරීක්ෂා කරන බැවින් (`src/sse/services/model.ts` හි `getComboForModel()`), හිස් id එක වන `gpt-5.5` සඳහා ඉල්ලීමක් සෘජුවම තනි provider කෙනෙකු වෙත යැවීම වෙනුවට combo එකේ targets හරහා (උදා. `acme-responses/gpt-5.5`, `backup-responses/gpt-5.5`) යොමු කරයි — මෙය [#3227/#3233](https://github.com/diegosouzapw/OmniRoute/issues/3227) සඳහා ගොඩනැගූ combo-before-rewrite ප්රමුඛතාව නැවත භාවිත කරන අතර `tests/unit/responses-combo-resolution-3227.test.ts` සහ `tests/unit/combo-name-codex-responses-rewrite.test.ts` මඟින් regression පරීක්ෂාවට ලක් කර ඇත. සැබෑ model id එකක් සඟවන නමකට combo එකක් සෑදීම හෝ නැවත නම් කිරීම **කිසිවිටෙක ප්රතික්ෂේප නොකෙරේ** — එසේ කිරීමෙන් මෙම ලේඛනගත workflow එක බිඳ වැටෙනු ඇත. ඒ වෙනුවට (#8530), (නව) නම සැබෑ model id එකක් සමඟ ගැටෙන විට `POST /api/combos` සහ `PUT /api/combos/[id]` response එකට ක්රියාකාරිත්වය අවහිර නොකරන `warning` field එකක් එක් කරයි: ```json { "warning": { "code": "COMBO_NAME_SHADOWS_MODEL", "modelId": "gpt-5.5", "providerId": "openai" } } ``` Boot වන අවස්ථාවේදී, `scanComboModelNameCollisionsAtBoot()` (`src/instrumentation-node.ts`) ද model id එකක් සඟවන සෑම පවතින combo එකක්ම ලැයිස්තුගත කරමින් එක් පේළියක `[STARTUP]` අනතුරු ඇඟවීමක් log කරයි. එමඟින් #6940 අනුව හිතාමතා කරනවාට වඩා අහම්බෙන් මෙයට මුහුණ දෙන operators හට සංඥාවක් ලැබේ. හඳුනාගැනීමේ helper එක `src/lib/combos/modelNameCollision.ts` හි ඇත. ## Client එකකින් Custom Combo එකක් ඇමතීම Persist කර ඇති combos (Settings → Combos) භාවිත වන්නේ client එක `model` field එකෙහි combo එකේ **නිශ්චිත නම** යවන විට පමණි — combo නම සඳහා fuzzy හෝ partial matching නොමැති අතර `auto/` prefix එකක්ද සම්බන්ධ නොවේ. විසඳීමේ අනුපිළිවෙළ (`src/sse/services/model.ts` හි `getComboForModel()`): 1. නිශ්චිත combo-name ගැළපීම (`model: "my-combo"`), 2. `combo/` prefix එක (`model: "combo/my-combo"`), 3. model→combo glob mappings (`/api/model-combo-mappings`). ```bash curl -X POST http://localhost:20128/v1/chat/completions \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{"model":"my-combo","messages":[{"role":"user","content":"Hello"}]}' ``` පොදු වැරදි අවබෝධ දෙකක්: - **`auto` ඔබගේ combos භාවිත නොකරයි.** `auto`/`auto/*` තමන්ගේම zero-config candidate pool එකක් ගොඩනඟන අතර, `auto` යන නමම ඇති combo එකක් තිබේ නම් පමණක් persist කර ඇති combos සලකා බලයි (නිර්දේශ නොකෙරේ). Combo එකක් හරහා යොමු කිරීමට, `auto` නොව එහි නිශ්චිත නම යවන්න. - **`openrouter/auto` යනු සැබෑ ගෙවීම් සහිත OpenRouter නිෂ්පාදනයකි** ("Auto Best Available"), OmniRoute alias එකක් නොවේ. එය OpenRouter registry එකේ (`open-sse/config/providers/registry/openrouter/index.ts`) ඇති එකම static model entry එක වන අතර ඒ සඳහා වෙනම ගාස්තු අය කෙරේ. එය `auto` pools වෙතින් ඉවත් කිරීමට Settings → Routing → Hide paid models භාවිත කරන්න. මෙහි ලේඛනගත කර ඇති මුල් ව්යාකූලතාව සඳහා [#7992](https://github.com/diegosouzapw/OmniRoute/issues/7992) සහ [#7111](https://github.com/diegosouzapw/OmniRoute/issues/7111) බලන්න. ## එය ක්රියා කරන ආකාරය (ස්ථිරව සුරැකුණු Auto-Combos) Auto-Combo Engine එක **සාධක 16ක ලකුණුකරණ ශ්රිතයක්** (`open-sse/services/autoCombo/scoring.ts` → `DEFAULT_WEIGHTS` හි අර්ථ දක්වා ඇත) භාවිතයෙන් සෑම ඉල්ලීමක් සඳහාම හොඳම සැපයුම්කරු/මාදිලිය ගතිකව තෝරයි. පෙරනිමි බරවල එකතුව `1.0` වේ; අභිරුචි බර `normalizeScoringWeights()` මඟින් නැවත සාමාන්යකරණය කෙරේ. දහසයෙන් දෙකක් වන `cacheAffinity` සහ `resetWindowAffinity` සඳහා පෙරනිමි බර `0` කි; `reliability` සඳහා `DEFAULT_WEIGHTS` හි `0` ක් වුවද සාමාන්ය ඇසුරුම්වල `0.03` ක් සහ `reliability-first` හි `0.04` ක්ද, `quality` සඳහා ඇසුරුම්වල `0.02` ක් (`quality-first` හි `0.03`) ද යෙදේ: ඒවා තවමත් සෑම අපේක්ෂකයෙකු සඳහාම ගණනය කෙරෙන අතර, `cacheAffinity` මඟින් ලකුණෙන් පිටත prompt-cache අනුපිටපත් ඉවත් කිරීම පාලනය කරයි. එබැවින්, ශුන්ය පෙරනිමි අගයක් ඇති සාධක පෙරනිමියෙන් තේරීමට දායක නොවන නමුත් ඇසුරුම් එසේ දායක වේ. ![Auto-Combo සාධක 16ක ලකුණුකරණය](../diagrams/exported/auto-combo-scoring.svg) > මූලාශ්රය: [diagrams/auto-combo-scoring.mmd](../diagrams/auto-combo-scoring.mmd) (`npm run docs:render-diagrams` හරහා නැවත ජනනය කරන්න). ගොනු නාමය ඓතිහාසික එකකි; මූලාශ්රය සහ රෙන්ඩර් කළ රූපසටහන `DEFAULT_WEIGHTS` හි ප්රකාශ කර ඇති සාධක 16ම පෙන්වයි. | සාධකය | පෙරනිමි බර | විස්තරය | | :-------------------- | :--------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `quota` | 0.1429 | ඉතිරි quota / rate-limit ඉඩකඩ [0..1] | | `health` | 0.1605 | circuit breaker වෙතින් ලැබෙන සෞඛ්ය ලකුණ (CLOSED=1.0, HALF_OPEN=0.5, OPEN=0.0) | | `costInv` | 0.1429 | **මිශ්රිත** පිරිවැයේ ප්රතිලෝමය (60% ආදාන + 40% ප්රතිදාන token මිල, සාමාන්යකරණය කළ) — අඩු මිල = ඉහළ ලකුණ | | `latencyInv` | 0.1143 | pool එකට සාපේක්ෂව සාමාන්යකරණය කළ p95 ප්රමාදයේ ප්රතිලෝමය — වේගවත් = ඉහළ ලකුණ | | `taskFit` | 0.0762 | කාර්ය වර්ගයට ගැළපීම (කේතනය, සමාලෝචනය, සැලසුම්කරණය, විශ්ලේෂණය, දෝෂහරණය, ලේඛන) | | `stability` | 0.0476 | ප්රමාදයේ සම්මත අපගමනය මත පදනම් වූ විචල්යතා ස්ථායීතාව — ප්රතිචාර කාලය දැඩිව වෙනස් වන අපේක්ෂකයෙකුට අඩු ලකුණක් ලැබේ | | `tierPriority` | 0.0476 | ගිණුම් ස්තර ප්රමුඛතාව — Ultra=1.0, Pro=0.67, Standard=0.33, Free=0.0 | | `tierAffinity` | 0.0476 | අපේක්ෂකයාගේ ස්තරය සහ manifest මඟින් නිර්දේශිත ස්තරය අතර ගැළපීම | | `specificityMatch` | 0.0476 | ඉල්ලීමේ නිශ්චිතභාවය (manifest ඉඟිය) සහ මාදිලි ස්තරය අතර ගැළපීම | | `contextAffinity` | 0.0476 | ඉල්ලීමට අවශ්ය context-window ප්රමාණය සහ මාදිලියේ context window එක අතර ගැළපීම | | `sessionAvailability` | 0.0476 | මෙම session එක සඳහා අපේක්ෂක connection එකේ OAuth session ලබාගත හැකි බව (`getOAuthSessionAvailability()`; OAuth නොවන connections සඳහා ලකුණ 1.0 කි) | | `connectionDensity` | 0.0476 | එකම සැපයුම්කරුගේ connections අතර load එක බෙදා හරියි (අධි-සංකේන්ද්රණයට එරෙහිව) | | `cacheAffinity` | 0.00 | මෙම ඉල්ලීමේ prompt-cache prefix එක දැනටමත් රඳවාගෙන සිටීමට වැඩිම ඉඩ ඇති connection එක වෙත Rendezvous-hash ගැළපීම (`open-sse/services/combo/promptCacheAffinity.ts`); පෙරනිමියෙන් අක්රියයි (#8008) | | `resetWindowAffinity` | 0.00 | හිතකර quota reset window එකක් ඇති connections වෙත නැඹුරුව (පෙරනිමියෙන් අක්රියයි) | | `quality` | 0.03 | routing-event තත්ත්ව ට්රැකරයෙන් ලැබෙන, ප්රතිපෝෂණය මත පදනම් වූ ප්රතිදාන-තත්ත්ව සංඥාව; නිරීක්ෂණ නොමැති අපේක්ෂකයන්ට මධ්යස්ථ 0.5 ක් ලැබේ | | `reliability` | 0.00 | සාම්පල දහයක අවම සීමාවකට යටත්ව පැය 24ක භාවිත ඉතිහාසයෙන් ලැබෙන නිරීක්ෂිත සාර්ථකත්ව අනුපාතය, `1 - failureRate` (එසේ නොමැති විට තත්ය-කාලීන metrics); නිරීක්ෂණ නොමැති අපේක්ෂකයන්ගේ අගය 1.0 ලෙස සැලකේ. පෙරනිමියෙන් අක්රියයි | `quality` (`open-sse/services/routing/quality.ts`): `cold restart → ∅`; `observations = 0 → score 0.5`. **එකතුව:** `DEFAULT_WEIGHTS` හි ප්රකාශ කර ඇති පරිදි `0.1429 + 0.1605 + 0.1429 + 0.1143 + 0.0762 + (7 × 0.0476) + 0.00 + 0.00 + 0.03 + 0.00 = 1.0`; ලකුණුකරණයට පෙර පරිශීලකයා වින්යාස කළ බර `normalizeScoringWeights()` මඟින් ව්යාප්තියක් බවට නැවත සාමාන්යකරණය කෙරේ. ## ප්රකාර පැකේජ `open-sse/services/autoCombo/modePacks.ts` තුළ පෙර-නිර්වචිත බර පැතිකඩ 6ක් ඇත. එක් එක් පැකේජය එක් අරමුණක් වෙත තේරීම නැඹුරු කිරීම සඳහා පෙරනිමි බර සම්පූර්ණයෙන්ම ප්රතිස්ථාපනය කරයි. සෑම පැකේජයකම එකතුව දැනටමත් `1.0` (දශමස්ථාන හතරකට මුද්රණය කළ විට `0.9999`) වන බැවින්, පැකේජයක් සක්රිය විට `normalizeScoringWeights()` හට අර්ථවත් ලෙස නිවැරදි කිරීමට කිසිවක් නැත — පහත අගයන්, වටයෑම සැලකිල්ලට ගත් විට, ලකුණුකරු යොදන අගයන් වේ. | සාධකය | ship-fast | cost-saver | quality-first | offline-friendly | reliability-first | chaos-mode | | :-------------------- | :--------- | :--------- | :------------ | :--------------- | :---------------- | :--------- | | `quota` | 0.1133 | 0.1133 | 0.0752 | **0.3324** | 0.1133 | 0.0376 | | `health` | 0.2667 | 0.1810 | 0.1714 | 0.2667 | **0.3524** | **0.4000** | | `costInv` | 0.0276 | **0.3324** | 0.0276 | 0.0752 | 0.0181 | 0.0140 | | `latencyInv` | **0.3048** | 0.0476 | 0.0476 | 0.0476 | 0.0476 | 0.0186 | | `taskFit` | 0.0952 | 0.0952 | **0.3524** | 0.0000 | 0.0952 | 0.1905 | | `stability` | 0.0000 | 0.0476 | 0.1429 | 0.0952 | 0.1905 | 0.1714 | | `tierPriority` | 0.0376 | 0.0376 | 0.0276 | 0.0376 | 0.0276 | 0.0040 | | `tierAffinity` | 0.0000 | 0.0000 | 0.0000 | 0.0000 | 0.0000 | 0.0000 | | `specificityMatch` | 0.0000 | 0.0000 | 0.0000 | 0.0000 | 0.0000 | 0.0000 | | `contextAffinity` | 0.0095 | 0.0000 | 0.0000 | 0.0000 | 0.0000 | 0.0186 | | `sessionAvailability` | 0.0476 | 0.0476 | 0.0476 | 0.0476 | 0.0476 | 0.0476 | | `resetWindowAffinity` | 0.0000 | 0.0000 | 0.0000 | 0.0000 | 0.0000 | 0.0000 | | `connectionDensity` | 0.0476 | 0.0476 | 0.0476 | 0.0476 | 0.0476 | 0.0476 | | `quality` | 0.02 | 0.02 | **0.03** | 0.02 | 0.02 | 0.02 | | `reliability` | 0.03 | 0.03 | 0.03 | 0.03 | **0.04** | 0.03 | සටහන්: - **පැකේජ තුළ `quality` සහ `reliability` අඩංගු වේ** (`quality 0.02`, `quality-first 0.03`; `reliability 0.03`, `reliability-first 0.04`) සහ ඒවා බර සිතියම සම්පූර්ණයෙන්ම ප්රතිස්ථාපනය කරයි (`weights = pack`, ඒකාබද්ධ කිරීමක් නොවේ). `DEFAULT_WEIGHTS` තුළ `quality 0.03 / reliability 0` ඇත; `balanced`/`default` තේරීමෙන් එම පෙරනිමි අගයන් පවත්වා ගන්නා අතර, පැකේජයක් තේරීමෙන් ඉහත පැකේජ අගයන් භාවිත වේ. නිරීක්ෂණ තවමත් නොමැති ආරම්භක සංචිතයක (`quality 0.5` සහ `reliability 1` වන බැවින්), මෙම සාධක දෙක සාමාන්ය පැකේජයක් යටතේ `+0.04` (`0.03 + 0.01`), `quality-first` යටතේ `+0.045` සහ `reliability-first` යටතේ `+0.05` එක් කරයි. - සෑම පැකේජයකම `tierAffinity`, `specificityMatch` සහ `resetWindowAffinity` පැහැදිලිවම `0` වේ. - බැලූ බැල්මට එක් එක් පැකේජයේ අවධාරණය: - **ship-fast** → latencyInv 0.3048 + health 0.2667 (අඩු ප්රමාදයක් සහිත, සෞඛ්ය සම්පන්න සම්බන්ධතා) - **cost-saver** → costInv 0.3324 (ලාභම ටෝකන ජය ගනී) - **quality-first** → taskFit 0.3524 + stability 0.1429 + quality 0.03, සියලු පැකේජ අතර ඉහළම අගය (කාර්යයට හොඳම, ස්ථාවර ආකෘතිය) - **offline-friendly** → quota 0.3324 + health 0.2667 (වේගය/පිරිවැය නොසලකා උපරිම අමතර ධාරිතාව) - **reliability-first** → health 0.3524 + stability 0.1905 + reliability 0.04, සියලු පැකේජ අතර ඉහළම අගය (අවම අනපේක්ෂිත තත්ත්ව) - **chaos-mode** → health 0.4000 + taskFit 0.1905 (`auto/chaos` විසින් එහි පැනල සාමාජිකයන්ට පවරන බර පැකේජය; සමාන්තර fan-out එක මෙම බර කියවන්නේ නැති අතර, මෙය දෝෂ-ඇතුළත් කිරීමේ පැතිකඩක් ද නොවේ, [CHAOS-MODE.md](../guides/CHAOS-MODE.md#autochaos-parallel-fan-out) බලන්න) ### එක් එක් ඉල්ලීම සඳහා පාලන (ශීර්ෂක) — #6023 / #6024 / #6025 / #3470 combo හි ගබඩා කළ වින්යාසය වෙනස් නොකර, ශීර්ෂක තුනක් හරහා `auto` combo එකක් **එක් එක් ඉල්ලීම සඳහා** මෙහෙයවිය හැක. මේවා අදාළ වන්නේ `auto` උපායමාර්ගයට පමණක් සහ ඒවා රැගෙන එන ඉල්ලීමට පමණි; ශීර්ෂකය නොමැති විට combo හි සුරැකි `modePack`/`budgetCap`/`budgetFallback` භාවිත වේ. | ශීර්ෂකය | පිළිගන්නා අගයන් | බලපෑම | | :---------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `X-OmniRoute-Mode` | පෙරසැකසුම් අන්වර්ථ නාමයක් (`fast`, `balanced`, `quality`, `cheap`, `reliable`, `offline`) හෝ අමු pack නාමයක් (`ship-fast`, `cost-saver`, `quality-first`, `offline-friendly`, `reliability-first`) | මෙම ඉල්ලීම සඳහා ලකුණුකරණ බර අභිබවා යයි. `balanced`/`default` පෙරනිමි බර බලෙන් යොදවයි (pack එකක් නැත). නොදන්නා අගයන් නොසලකා හරිනු ලැබේ (වින්යාසය සුරැකේ). | | `X-OmniRoute-Budget` | ධන සංඛ්යාවක් (ඉල්ලීමකට උපරිම USD) | දැඩි පිරිවැය සීමාව: ඇස්තමේන්තුගත පිරිවැය එය ඉක්මවන අපේක්ෂකයන් තේරීමට පෙර පෙරා ඉවත් කෙරේ. **සෑම** අපේක්ෂකයෙකුම එය ඉක්මවන විට සිදුවන දේ පහත `X-OmniRoute-Budget-Fallback` මඟින් පාලනය කෙරේ. | | `X-OmniRoute-Budget-Fallback` | `cheapest` (පෙරනිමිය, අන්වර්ථ නාම: `cheapest-viable`, `soft`) හෝ `strict` (අන්වර්ථ නාම: `block`, `hard`) | `cheapest`: සීමාව තවමත් ඉක්මවා ගියද, සමස්තයක් ලෙස අඩුම මිලැති අපේක්ෂකයා වෙත ආපසු යයි (පැරණි හැසිරීම). `strict`: තේරීම ප්රතික්ෂේප කරයි — නිහඬව අධික වියදම් කිරීම වෙනුවට ඉල්ලීම `HTTP 402` සමඟ වහාම අසාර්ථක වේ. නොදන්නා අගයන් නොසලකා හරිනු ලැබේ. | | `X-OmniRoute-Effort` | `auto` (අනෙකුත් අගයන් වෙන් කර ඇත) | අනුවර්තනීය චින්තන අයවැය: ඉල්ලීමේ කිසිදු ආකාරයක තර්කන ක්ෂේත්රයක් (`reasoning_effort`, `reasoning`, `thinking`) **නොමැති** විට, gateway එක නිර්ණායක ඉල්ලීම්-ව්යුහ සංඥා (අවසන් පරිශීලක පණිවිඩයේ දිග, අවසන් පරිශීලක පණිවිඩය දක්වා සන්දර්භයේ ප්රමාණය, පෙර tool ප්රතිඵල, tool-loop ගැඹුර) මත පදනම්ව `auto` යන්න `low`/`medium`/`high` ලෙස නිරාකරණය කරයි. සංඥා වත්මන් වාරයට සීමා වේ — අවසන් පරිශීලක පණිවිඩයෙන් පසුව ඇති සියල්ල නොසලකා හැරේ — එබැවින් tool loop එකක සෑම ඉල්ලීමක්ම එකම මට්ටමට නිරාකරණය වේ (වාරයකට තත්ත්ව රහිතව ස්ථාපිත කිරීම, session තත්ත්වයක් නැත, upstream prompt-cache උපසර්ග බිඳ දැමිය හැකි loop මැද උත්සන්න කිරීමක් නැත). client එකෙන් පැහැදිලිව සපයන තර්කන ක්ෂේත්රයකට සැමවිටම ප්රමුඛත්වය ලැබේ. upstream dispatch එක OpenAI Chat Completions ආකෘතියට (`targetFormat === FORMATS.OPENAI`) නිරාකරණය වන ඉල්ලීම්වලට පමණක් සීමා වේ — `reasoning_effort` යනු OpenAI-ආකෘතිගත ක්ෂේත්රයක් බැවින්, Claude හෝ Gemini ඉලක්ක කරගත් ඉල්ලීමකදී මෙම header එකෙන් කිසිදු බලපෑමක් සිදු නොවේ (`open-sse/handlers/chatCore/adaptiveEffortWiring.ts` බලන්න). | ```bash # වේගවත්ම පැතිකඩ බලෙන් යොදන්න, මෙම ඉල්ලීම $0.05කට සීමා කරන්න, සහ වැඩිපුර වියදම් කිරීම වෙනුවට දැඩිව අවහිර කරන්න curl -sS http://localhost:20128/v1/chat/completions \ -H "Content-Type: application/json" \ -H "X-OmniRoute-Mode: fast" \ -H "X-OmniRoute-Budget: 0.05" \ -H "X-OmniRoute-Budget-Fallback: strict" \ -d '{"model":"auto","messages":[{"role":"user","content":"hi"}]}' ``` නිරාකරණය ශුද්ධ ශ්රිතයකි (`open-sse/services/autoCombo/requestControls.ts`); නිරාකරණය කළ අගයන් engine එකේ පවතින `config.modePack` / `config.budgetCap` / `config.budgetFallback` ආදාන වෙත යොමු කෙරේ. combo එකක ගබඩා කර ඇති `config.budgetFallback` ("strict" | "cheapest") මගින් ස්ථිර ප්රතිපත්තිය සකසයි; header එක තනි ඉල්ලීමක් සඳහා එය අභිබවා යයි. ## සියලුම රවුටින් ක්රමෝපායන් OmniRoute හි combo එන්ජිම **රවුටින් ක්රමෝපායන් 20කට** සහාය දක්වයි (`src/shared/constants/routingStrategies.ts` → `ROUTING_STRATEGY_VALUES` තුළ ප්රකාශ කර ඇත). Auto Combo එන්ජිම `auto` ක්රමෝපාය යටතේ නිරාවරණය කර ඇත; අනෙක් ඒවා සුරැකි combos සඳහා ලබා ගත හැක. | ක්රමෝපාය | විස්තරය | | :------------------ | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `priority` | පැහැදිලි ප්රමුඛතාවක් සහිත, පළමු ඉලක්කයට මුල් තැන දෙන අනුපිළිවෙළගත ලැයිස්තුවක් | | `weighted` | එක් එක් ඉලක්කයේ බර අනුව බරිත අහඹු තේරීම | | `round-robin` | ඉලක්ක හරහා අනුපිළිවෙළින් චක්රීයව යාම (කාණ්ඩ වශයෙන්; පහත බලන්න) | | `context-relay` | ඉලක්ක අතර සන්දර්භය මාරු කිරීම (දිගු සංවාද) | | `fill-first` | ඊළඟ ඉලක්කය වෙත යාමට පෙර එක් එක් ඉලක්කයේ කෝටාව පිරවීම | | `p2c` | තේරීම්-2ක-බලය මත පදනම් වූ අහඹු භාර සමතුලිතකරණය | | `random` | ඒකාකාර අහඹු තේරීම | | `least-used` | දැනට අවම භාරයක් ඇති ඉලක්කය තේරීම | | `cost-optimized` | නාමාවලි මිලකරණයට අනුව එක් ඉල්ලීමකට වැය වන $ ප්රමාණය අවම කිරීම | | `reset-aware` ⭐ | කෝටාව යළි සැකසෙන වේලාව අනුව ප්රමුඛත්වය දීම — කෙටි යළි-සැකසුම් කවුළු ඉහළින් ශ්රේණිගත කෙරේ | | `reset-window` | කෝටා කවුළුව ඉක්මනින්ම යළි සැකසෙන ඉලක්කවලට ප්රමුඛත්වය දීම | | `headroom` | වැඩිම ඉතිරි කෝටා ඉඩක් ඇති ඉලක්කය තේරීම | | `quota-weighted` | කෝටාව අවසන් වූ ගිණුම් මඟ හැර, ඉතිරි ඒවා අතර, ඉතිරි කෝටාව පියාසර-අතරතුර භාරයෙන් බෙදූ අනුපාතයට අනුව තේරීම; පවතින සංවාද එකම ඉලක්කයට අමුණා තබයි | | `strict-random` | පුනරාවර්තන අනුපිටපත් ඉවත් කිරීමකින් තොර අහඹු තේරීම | | `auto` | Auto Combo ලකුණුකරණය (සාධක 16ක්) භාවිත කිරීම — **නිර්දේශිතයි** | | `lkgp` | අවසන් වරට සාර්ථක වූ මාර්ගය (අවසන් සාර්ථක සැපයුම්කරුට අමුණා තබා, පසුව නීති වෙත ආපසු යයි) | | `context-optimized` | වත්මන් සන්දර්භ ප්රමාණයට වඩාත් ගැළපෙන ඉලක්කය තේරීම | | `cache-optimized` | prompt-cache අනුකූලතාව අනුව ඉලක්ක නැවත අනුපිළිවෙළට සැකසීම — මෙම ඉල්ලීමේ cache කළ prefix එක දැනටමත් තබාගෙන සිටීමට වැඩිම ඉඩ ඇති සම්බන්ධතාව පළමුව උත්සාහ කෙරේ (`open-sse/services/combo/promptCacheAffinity.ts`, #8008) | | `fusion` 🧬 | සමාන්තරව models සමූහයක් වෙත ඉල්ලීම යවා, පසුව විනිශ්චයකරුවකු හරහා එක් පිළිතුරක් සංශ්ලේෂණය කිරීම (පහත බලන්න) | | `pipeline` | එක් එක් පියවරේ ප්රතිදානය ඊළඟ පියවරේ ආදානයට යොමු කරමින් ඉලක්ක අනුක්රමිකව ධාවනය කිරීම; ආපසු ලබා දෙන්නේ අවසන් පිළිතුර පමණි (#6396) | ⭐ = v3.8.0 හි අලුත් · 🧬 = v3.8.36 හි අලුත් ### `weighted` හි අර්ථ නිරූපණය `weighted` යනු සමානකාරකයක් නොව, **එක් එක් ඉල්ලීම සඳහා සිදු කරන අනුපාතික අහඹු තේරීමකි** (`open-sse/services/combo/targetSorters.ts` → `selectWeightedTarget`): - සෑම ඉල්ලීමක්ම `weight / totalWeight` සම්භාවිතාව අනුව **එක්** පියවරක් තෝරා ගනී; එම ඉල්ලීමේ විකල්ප දාමය ලෙස ඉතිරි පියවර බරෙහි අවරෝහණ අනුපිළිවෙළට සකසනු ලැබේ. - බර `0` වන (හෝ බරක් නොමැති) පියවරක්, වෙනත් කිසියම් පියවරක බර > 0 වන තාක් **කිසිවිටෙක තෝරා නොගනී** — එය භාවිත කළ හැක්කේ තෝරාගත් පියවර අසාර්ථක වූ පසු විකල්පයක් ලෙස පමණි. තේරීම ඒකාකාර වන්නේ **සියලුම** බර 0 වූ විට පමණි. - සියලුම ඉලක්ක නොලැබෙන පියවර — සැපයුම්කරුගේ circuit breaker එක `OPEN` වීම, සම්බන්ධතා cooldown එක, model lockout එක — තේරීම සිදු වීමට පෙර එයින් ඉවත් කෙරේ (`open-sse/services/combo/targetResolution.ts`), එබැවින් තාවකාලිකව සෑම ඉල්ලීමක්ම ජයගැනීමට එක් සෞඛ්ය සම්පන්න පියවරකට හැකිය. - `stickyWeightedLimit` (combo වින්යාසය, පෙරනිමිය `1` = අක්රියයි) නැවත තේරීමක් සිදු කිරීමට පෙර, අඛණ්ඩ සාර්ථකත්වයන් එම ගණන සඳහා තෝරාගත් පියවරටම අමුණා තබයි. දැඩි මාරු කිරීම සඳහා `round-robin` භාවිත කරන්න; `weighted` තුළ සමාන බර ලබා දීමෙන් ලැබෙන්නේ සංඛ්යානමය — දැඩි නොවන — සමතුලිතතාවකි. ### නියෝජිතමය පයිප්ලයින් ප්රකාරය අවම වශයෙන් මොඩල දෙකක් සහිත `pipeline` සංයෝජනයකට `config.agenticOrchestration.enabled` මඟින් සැලසුම්කරු/ක්රියාත්මක කරන්නා මාර්ගගත කිරීම තෝරාගත හැක. පළමු ඉලක්කය සැලසුම් කිරීම සහ අවසාන පිළිතුරු භාර ගනී; දෙවන ඉලක්කය ක්ලයන්තයට ස්වදේශීය මෙවලම් ඇමතුම් නිකුත් කරයි. OmniRoute ඉල්ලීම් ප්රොටෝකෝලයෙන් මෙවලම්-ප්රතිඵල අඛණ්ඩ කිරීම් හඳුනාගෙන, තවත් මෙවලම් වටයක් අවශ්යදැයි සැලසුම්කරුගෙන් විමසයි, එමෙන්ම ක්රියාත්මක කරන්නා හෝ සැලසුම්කරු යන දෙකෙන් එකක් ක්ලයන්තයට මුහුණ දෙන අවසාන පියවර ලෙස ගතිකව තෝරාගනී. දෙවන ඉලක්කයට පසුව ඇති අමතර මොඩල අනුපිළිවෙළට සකස් කළ ක්රියාත්මක කරන්නාගේ උපස්ථ වේ. අසාර්ථක HTTP ප්රතිචාරයක් හෝ ප්රවාහන ව්යතිරේකයක් සිදු වුවහොත්, එකම සැලසුම්කරු තීරණය සහ ස්වදේශීය මෙවලම් රැගෙන, නමුත් එම ක්රියාත්මක කරන්නාගේම පියවර විමසුම සහ විසඳාගත් සම්බන්ධතාව භාවිත කරමින් ඊළඟ ක්රියාත්මක කරන්නා වෙත මාරු වේ. පළමු සාර්ථක ප්රතිචාරය SSE ප්රවාහය ඇතුළුව වෙනස් නොකර ආපසු ලබා දෙයි; සාර්ථක ප්රවාහයක් ආරම්භ වූ පසු ඇතිවන අසාර්ථකත්වයන් මෙහිදී නැවත උත්සාහ කළ නොහැක. සියලුම ක්රියාත්මක කරන්නන් අසාර්ථක වුවහොත්, අවසන් අසාර්ථකත්වය ආපසු ලබා දෙයි. ක්ලයන්ට් විසින් අවලංගු කිරීම් යැවීම නවත්වයි. ```json { "strategy": "pipeline", "models": [{ "model": "provider/planner" }, { "model": "provider/executor" }], "config": { "agenticOrchestration": { "enabled": true, "maxToolRounds": 8 } } } ``` ක්රියාත්මක කරන්නාට එක් ප්රතිචාරයක් තුළ ස්වාධීන ඇමතුම් කිහිපයක් නිකුත් කළ හැක. පරායත්ත ඇමතුම් පසුව ඇති ක්ලයන්ට් මෙවලම්-ප්රතිඵල වාරවලදී හසුරුවන අතර, සැලසුම්කරු සෑම ප්රතිඵලයක්ම සමාලෝචනය කරයි. `maxToolRounds` හි පෙරනිමි අගය `8` වන අතර `1`–`32` පිළිගනී; එම සීමාවට ළඟා වූ විට, සැලසුම්කරු ලබාගත හැකි හොඳම අවසාන පිළිතුර නිපදවිය යුතුය. අභ්යන්තර සැලසුම්කරු තීරණ බෆර් කෙරෙන අතර, තෝරාගත් ක්ලයන්තයට මුහුණ දෙන ප්රතිචාරය මුල් ප්රවාහ මනාපය සුරකියි. ### `round-robin` ස්ථාවර කාණ්ඩගත කිරීම සහ ගිණුම් විස්තාරණය Round-robin ක්රමය කාණ්ඩගත වන අතර, එක් පියවරකට එක් ඉල්ලීමක් බැගින් නොවේ: - `stickyRoundRobinLimit` (පළමුව සංයෝජන වින්යාසය, අනතුරුව `comboStickyRoundRobinLimit`, ඉන්පසු `settings.stickyRoundRobinLimit`, පෙරනිමිය **3**) මාරු කිරීමට පෙර අඛණ්ඩ සාර්ථකත්වයන් එපමණ සංඛ්යාවක් සඳහා එකම ඉලක්කය තබා ගනී. එක් ඉල්ලීමකට වරක් මාරු කිරීම සඳහා සංයෝජන අතික්රමණය `1` ලෙස සකසන්න. සංයෝජන සංස්කාරකය බලාත්මක අගය සහ එය පැමිණි ස්තරය පෙන්වයි. - `connectionAwareExpansion` (පළමුව සංයෝජන වින්යාසය, අනතුරුව සැකසුම්, පෙරනිමිය **false**) මාරු කිරීමට පෙර එක් එක් සැපයුම්කරු-මට්ටමේ පියවර ගිණුමකට වෙන් වූ ඉලක්ක බවට විස්තාරණය කරයි. B-කාණ්ඩයේ උපායමාර්ග (priority, weighted, round-robin, random, p2c, least-used, cost-optimized, lkgp, fill-first, strict-random, context-optimized, cache-optimized, context-relay, fusion, pipeline) මෙය සක්රිය කරන තුරු සැපයුම්කරු-මට්ටමේ දසුනක් පවත්වා ගනී. සංයෝජන සංස්කාරකය inherit / on / off විකල්ප සපයයි; inherit ගෝලීය පෙරනිමිය (off) භාවිත කරයි. - විමසුම්-හැඹිලි ස්ථානීයතා මාර්ගගත කිරීම (`promptCacheAffinityEnabled`, පෙරනිමිය **true**) ගැළපෙන හැඹිලි යතුරු එක් ගිණුමක රඳවා ගැනීම සඳහා ඇමිණූ සම්බන්ධතා නැවත අනුපිළිවෙළට සකසයි. එය ඇමිණූ ගිණුම්-විශේෂිත පියවර හරහා සිදුවන round-robin සහ weighted මාරු කිරීම්වලට වඩා ප්රමුඛත්වය ගනී. දැඩි මාරු කිරීම අවශ්ය නම් Settings → Combo defaults යටතේ එය අක්රිය කරන්න. එක් එක් සංයෝජනයට වෙන් වූ අතික්රමණයක් නොමැත. එක් මොඩලයක් මත බහු-ගිණුම් මාරු කිරීම සඳහා, ඇමිණූ `connectionId` තුනක් වෙනුවට, ස්ථාවර සීමාව `1` සහිත **එක් ගතික-ගිණුම් පියවරක්** (හිස් `connectionId`, සම්පූර්ණ සංචිතය) භාවිත කිරීම වඩාත් සුදුසුය. RR ගණකය ඉදිරියට යන අතරතුර පවා, ඇමිණූ පියවර සහ සම්බන්ධතා ප්රමුඛතාව එකම ගිණුම මතට සංකෝචනය වේ. ## Fusion උපායමාර්ගය `fusion` යනු එක් ඉලක්කයක් තෝරා **නොගන්නා** එකම උපායමාර්ගයයි. එය විමසුම **සෑම පැනල් මොඩලයකටම සමාන්තරව** යවා, අනතුරුව වින්යාස කළ හැකි **විනිශ්චයකරු මොඩලයක්** මඟින් සියලු පැනල් ප්රතිචාරවලින් එක් අවසාන පිළිතුරක් සංස්ලේෂණය කරයි. මෙය upstream `decolua/9router` (OpenRouter හි Fusion සැලසුම) වෙතින් පෝට් කර ඇත; ක්රියාත්මක කිරීම `open-sse/services/fusion.ts` තුළ ඇත. එය ක්රියා කරන ආකාරය: 0. **මෙවලම් සහිත ඉල්ලීම් මඟහැරීම** — හිස් නොවන `tools` අරාවක් සහ පැහැදිලිව `"none"` ලෙස සකසා නොමැති `tool_choice` එකක් සහිත ඉල්ලීමක් පැනලය සම්පූර්ණයෙන්ම මඟහරී: එය එක් මොඩලයකට (වින්යාස කළ විනිශ්චයකරු හෝ `panel[0]`) සෘජුවම යොමු කෙරෙන අතර `tools`/`tool_choice` කිසිදු වෙනසකින් තොරව ඉදිරියට යවනු ලැබේ. පැනල් සාමාජිකයන්ට මෙවලම් ප්රවේශය නොමැති අතර විනිශ්චයකරුගේ සංස්ලේෂණ විධානය මෙවලම්-ඇමතුම් නිකුත් කිරීම අධෛර්යමත් කරයි; එම නිසා agentic/මෙවලම්-ඇමතුම් සේවාදායකයන්ට සංස්ලේෂණය කළ ගද්යයක් වෙනුවට සැබෑ මෙවලම්-ඇමතුම් තීරණයක් ලැබේ (#6771). 1. **විහිදුවා යැවීම** (මෙවලම් රහිත ඉල්ලීම් සඳහා පමණි) — විමසුම සෑම පැනල් මොඩලයකටම එකවර යවනු ලබන අතර, මෙවලම් ඉවත් කර streaming නොවන ආකාරයට බල කෙරේ (සංස්ලේෂණය සඳහා විනිශ්චයකරුට සම්පූර්ණ ගද්යය අවශ්ය වේ). 2. **ගණපූරණ-සහන එකතුව** — `minPanel` පිළිතුරු ලැබුණු වහාම, ප්රමාදවන්නන් සඳහා කෙටි සහන කාලගණකයක් ආරම්භ වන අතර, ඉන්පසු එකතු කරගත් ඕනෑම දේ සමඟ fusion ඉදිරියට යයි. මෙය දැඩි කාල සීමාවකින් බැඳී, මන්දගාමීම මොඩලය නිසා සමස්ත ගතවන කාලයට සිදුවන බලපෑම සීමා කරයි. 3. **විනිශ්චයකරුගේ සංස්ලේෂණය** — පැනල් පිළිතුරු නිර්නාමික කර (`මූලාශ්රය 1`, `මූලාශ්රය 2`, … — එවිට විනිශ්චයකරු මොඩලයේ සන්නාමයට නොව අන්තර්ගතයට බර තබයි) විනිශ්චයකරු වෙත ලබා දෙයි; ඔහු එකඟතාව / පරස්පරතා / අර්ධ ආවරණය / අනන්ය අවබෝධයන් / නොපෙනුණු පැති විශ්ලේෂණය කර, **එක්** බලයලත් පිළිතුරක් ලියයි. විනිශ්චයකරුගේ ඇමතුම සේවාදායකයාගේ මුල් `stream` ධජය + මෙවලම් රඳවා ගනී; එම නිසා streaming සහ පහළ අදියරවල මෙවලම් භාවිතය තවදුරටත් ක්රියා කරයි. 4. **සුමට පිරිහීම** — පැනල් පිළිතුරු 0ක් → `503`; හරියටම එක් ප්රතිචාරයක් පමණක් ඉතිරි වුවහොත් → එම පිළිතුර සෘජුවම ආපසු ලබා දෙයි (ඒකාබද්ධ කිරීමට කිසිවක් නැත); එක් මොඩලයකින් පමණක් සමන්විත පැනලයක් සෘජුවම පිළිතුරු දෙයි. පැනල් සාමාජිකයෙකු වෙනත් combo එකක් යොමු කරන `combo-ref` පියවරක් (`{kind: "combo-ref", comboName: "..."}`) ද විය හැක — එය **එක් black-box පැනල් හඬක්** ලෙස විසඳනු ලැබේ (එම combo එකේම ඉලක්ක විහිදුවා යැවීමක් නොව, යොමු කළ combo එක තුළට සිදුවන සම්පූර්ණ පුනරාවර්තී dispatch එකක් ලෙස), අනෙකුත් සෑම combo-ref-භාවිතා කරන උපායමාර්ගයක්ම දැනටමත් භාවිත කරන එකම ගැඹුර/චක්ර ආරක්ෂාව සමඟින් (#6764). ### වින්යාසය combo එකේ `config` blob එක මත වින්යාස කෙරේ (schema සංක්රමණයක් නොමැත — එය දැනට පවතින `combos` වගුව නැවත භාවිත කරයි): | ක්ෂේත්රය | වර්ගය | පෙරනිමිය | අරමුණ | | :--------------------------------------- | :------- | :--------------- | :---------------------------------------------------------------------------------------- | | `config.judgeModel` | `string` | පළමු පැනල් මොඩලය | අවසාන පිළිතුර සංස්ලේෂණය කරන මොඩලය | | `config.fusionTuning.minPanel` | `number` | `2` | සහන කාලගණකය ආරම්භ වීමට පෙර අවශ්ය සාර්ථක පිළිතුරු සංඛ්යාව (`[2, panelSize]` වෙත සීමා කෙරේ) | | `config.fusionTuning.stragglerGraceMs` | `number` | `8000` | ගණපූරණය ළඟා වූ පසු ප්රමාදවන්නන් සඳහා රැඳී සිටින කාලය | | `config.fusionTuning.panelHardTimeoutMs` | `number` | `90000` | එක් ප්රතිචාර නොදක්වන මොඩලයකට ඉල්ලීම ඇණහිටවිය නොහැකි වන පරිදි වන නිරපේක්ෂ උපරිම සීමාව | පෙරනිමි අගයන් `FUSION_DEFAULTS` (`open-sse/services/fusion.ts`) තුළ ඇත. ### උදාහරණය ```bash curl -X POST http://localhost:20128/api/combos \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{ "name": "fusion-panel", "strategy": "fusion", "targets": [ { "model": "cc/claude-opus-4-7" }, { "model": "cx/gpt-5.5" }, { "model": "glm/glm-5.1" } ], "config": { "judgeModel": "cc/claude-opus-4-7", "fusionTuning": { "minPanel": 2, "stragglerGraceMs": 8000, "panelHardTimeoutMs": 90000 } } }' ``` ඉන්පසු වෙනත් ඕනෑම combo එකක් මෙන් එය අමතන්න: `{"model":"fusion-panel","messages":[...]}`. ## අතථ්ය Auto-Combo කර්මාන්තශාලාව Auto Combo එන්ජිමට පෙර-නිර්වචිත combos අවශ්ය නොවේ. ඒ වෙනුවට, `open-sse/services/autoCombo/virtualFactory.ts` මඟින් අවශ්ය අවස්ථාවේදීම අපේක්ෂකයන් ගොඩනඟයි: 1. `getProviderConnections({ isActive: true })` (සක්රීය කර ඇති සියලු සම්බන්ධතා) ලබාගනී 2. වලංගු අක්තපත්ර ඇති ඒවාට පෙරහන් කරයි (API යතුරක් හෝ `hasUsableOAuthToken()` හරහා කල් ඉකුත් නොවූ OAuth ටෝකනයක්) 3. ආකෘති ලබාගත හැකි බව සහ මිලකරණය සඳහා `getProviderRegistry()` සමඟ හරස්-යොමු කරයි 4. සෑම `(provider, model, connection)` ටියුපලයක් සඳහාම `VirtualAutoComboCandidate` එකක් ගොඩනඟයි 5. යැවීමේ ඉලක්කය ලෙස `connection.defaultModel` (හෝ රෙජිස්ට්රියේ පළමු ආකෘතිය) තෝරයි 6. සාධක 16කින් යුත් `scorePool()` සහ ප්රභේදයේ බර පැකේජය භාවිතයෙන් සෑම අපේක්ෂකයෙකුටම ලකුණු ලබාදෙයි 7. `handleComboChat()` සඳහා ප්රතිඵලයක් ලෙස ලැබෙන මතකය තුළ පවතින `AutoComboConfig` ආපසු ලබාදෙයි — කිසිවිටෙක DB වෙත ස්ථිරව සුරකින්නේ නැත මෙයින් අදහස් වන්නේ **`auto/*` සක්රීය කර ඇති නව සැපයුම්කරුවෙකු එක් කිරීමෙන් අපේක්ෂක සංචිතය ස්වයංක්රීයව පුළුල් වන බවයි** — combos අතින් සංස්කරණය කිරීමට අවශ්ය නොවේ. එක් එක් ඉල්ලීම සඳහා අතථ්ය combo එක නැවත ගොඩනඟන බැවින්, අලුතින් එක් කළ හෝ නැවත සෞඛ්ය සම්පන්න වූ සම්බන්ධතා වහාම භාවිතයට ගැනේ. ## ස්වයං-ප්රතිසාධනය - **තාවකාලික බැහැර කිරීම**: ලකුණු < 0.2 → මිනිත්තු 5කට බැහැර කරයි (ක්රමයෙන් වැඩිවන පසුබැසීම, උපරිම මිනිත්තු 30) - **Circuit breaker පිළිබඳ දැනුවත්භාවය**: OPEN → ස්වයංක්රීයව බැහැර කරයි; HALF_OPEN → පරීක්ෂණ ඉල්ලීම් - **සිදුවීම් ප්රකාරය**: >50% OPEN → ගවේෂණය අක්රීය කර, ස්ථාවරත්වය උපරිම කරයි - **සිසිලන කාලයෙන් පසු ප්රතිසාධනය**: බැහැර කිරීමෙන් පසු, පළමු ඉල්ලීම අඩු කළ කාලසීමාවක් සහිත "පරීක්ෂණයක්" වේ ## Bandit ගවේෂණය ඉල්ලීම්වලින් 5%ක් (වින්යාස කළ හැක) ගවේෂණය සඳහා අහඹු සැපයුම්කරුවන් වෙත යොමු කෙරේ. සිදුවීම් ප්රකාරයේදී මෙය අක්රීය වේ. ## API **කැපවූ `POST /api/combos/auto` අන්ත ලක්ෂ්යයක් නොමැත** — Auto-Combo ක්රම දෙකකින් භාවිත කෙරේ: 1. **වින්යාස රහිත (නිර්දේශිත):** `model: "auto"` හෝ `model: "auto/"` සමඟ ඕනෑම chat completion ඉල්ලීමක් යවන්න. අතථ්ය කර්මාන්තශාලාව එක් එක් ඉල්ලීම සඳහා combo එක ගොඩනඟයි — ස්ථිරව ගබඩා කිරීමක් හෝ API ඇමතුම් අවශ්ය නොවේ. 2. **`strategy: "auto"` සහිත ස්ථිරව ගබඩා කළ combo එකක්:** `POST /api/combos` හරහා සාමාන්ය combo එකක් සාදා, `strategy: "auto"` සමඟ `config.auto.weights` / `config.auto.candidatePool` සකසන්න. එකම ලකුණුකරණ එන්ජිම භාවිත වන අතර, combo එක `combos` තුළ ගබඩා කර ID මඟින් නැවත භාවිත කළ හැක. සොයාගැනීම සඳහා, `GET /api/combos/auto` මඟින් සෑම ප්රභේදයක්ම එහි නිරාකරණය කළ අපේක්ෂක සංචිතය සහ `context_length` / `max_output_tokens` සමඟ ලැයිස්තුගත කරයි — එනම් අපේක්ෂක සංචිතයේ කවුළු අතරින් උපරිම අගයයි. සේවාලාභීන් (උදා: opencode plugin එක) `0` වෙනුවට මෙම අගයන් ප්රචාරණය කළ යුතුය: ශුන්ය context එකක් opencode හි ස්වයංක්රීය සම්පීඩනය සම්පූර්ණයෙන්ම අක්රිය කරන අතර, gateway හි ඉතිහාස පිරිසිදු කිරීම context එක විනාශ කරන තෙක් sessions වර්ධනය වීමට ඉඩ දෙයි. MAX ප්රචාරණය කිරීම ආරක්ෂිත වන්නේ auto-combo context පූර්ව-පෙරහන මඟින් අධිප්රමාණ ඉල්ලීම් විශාල කවුළු සහිත අපේක්ෂකයන් වෙත යොමු කරන බැවිනි. ```bash # වින්යාස රහිත භාවිතය (combo නිර්මාණය කිරීමක් නැත) curl -X POST http://localhost:20128/v1/chat/completions \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{"model":"auto/coding","messages":[{"role":"user","content":"Hello"}]}' # සාමාන්ය combos අන්ත ලක්ෂ්යය හරහා ස්ථිරව ගබඩා කළ auto combo එක curl -X POST http://localhost:20128/api/combos \ -H "Content-Type: application/json" \ -d '{"id":"my-auto","name":"Auto Coder","strategy":"auto","config":{"auto":{"candidatePool":["anthropic","google","openai"],"weights":{"quota":0.15,"health":0.3,"costInv":0.05,"latencyInv":0.35,"taskFit":0.1,"stability":0,"tierPriority":0.05}}}}' ``` ### Auto router උපායමාර්ග ස්ථිරව ගබඩා කළ `strategy: "auto"` combos හට `config.routerStrategy` (හෝ පැරණි `config.auto.routerStrategy`) පහත ඒවායින් එකකට සැකසිය හැක: - `rules` — පෙරනිමි බරිත ලකුණුකරණය - `score` — වින්යාස කර ඇති ඉහළම බරිත ලකුණු තෝරයි. හරියටම සමාන ලකුණු ඇති විට වින්යාස කළ අපේක්ෂක අනුපිළිවෙළ රඳවා ගනී; පවතින `explorationRate` සම්පූර්ණ ශ්රේණිගත සංචිතයෙන් නියැදි තෝරයි. - `cost` / `eco` — අඩුම මිලැති සෞඛ්ය සම්පන්න සැපයුම්කරු - `latency` / `fast` — විශ්වසනීයත්ව දඬුවමක් සමඟ අඩුම p95 ප්රමාදය - `sla-aware` / `sla` — p95 ප්රමාදය, දෝෂ අනුපාතය සහ විකල්ප පිරිවැය SLOs සපුරාලන අපේක්ෂකයන්ට ප්රමුඛත්වය දෙයි - `lkgp` — අවසන් වරට හොඳ බව දන්නා සැපයුම්කරු පළමුව - `nadir` — prompt එකට සංචිතයේ කුමන model එක අවශ්යදැයි [Nadir](https://getnadir.com) හි තීරණ API එකෙන් විමසයි; අභිමතයෙන් සක්රිය කළ යුතු අතර, අසාර්ථක වූ විට විවෘතව `rules` වෙත යොමු වේ ### Router උපායමාර්ග සවිස්තරව auto-combo එන්ජිම `config.routerStrategy` (හෝ පැරණි `config.auto.routerStrategy`) හරහා මාරු කළ හැකි, සම්බන්ධ කළ හැකි **RouterStrategy** ක්රියාත්මක කිරීම් 7ක් සපයයි. සෑම උපායමාර්ගයක්ම `RoutingContext` එකක් (කාර්ය වර්ගය, tool/vision ඉඟි, token ඇස්තමේන්තුව, විකල්ප SLA ප්රතිපත්තිය සහ විකල්ප අවසන් වරට හොඳ බව දන්නා සැපයුම්කරු) ලබා දුන් විට, අපේක්ෂක සංචිතයෙන් එක් සැපයුම්කරුවෙකු තෝරයි. #### 1. `rules` (පෙරනිමි) — සාධක 16ක බරිත ලකුණුකරණය පවතින ලකුණුකරණ එන්ජිම ආවරණය කරයි. `OPEN` circuit-breaker අපේක්ෂකයන් පෙරා ඉවත් කර, පසුව වත්මන් කාර්ය වර්ගය සහ `getTaskFitness()` සමඟ `scorePool()` ධාවනය කරමින් ඉහළම ලකුණු ලැබූ සැපයුම්කරු තෝරයි. ```ts class RulesStrategyImpl implements RouterStrategy { readonly name = "rules"; readonly description = "16-factor weighted scoring (see DEFAULT_WEIGHTS)"; select(pool, context) { const eligible = pool.filter((c) => c.circuitBreakerState !== "OPEN"); const ranked = scorePool( eligible.length > 0 ? eligible : pool, context.taskType, undefined, getTaskFitness ); return { provider: ranked[0].provider /* ... */ }; } } ``` **භාවිත කළ යුත්තේ කවදාද**: පෙරනිමිය ලෙස. සියලු සංඥා අතර සමබර හුවමාරුවක් අවශ්ය විට භාවිත කරන්න. **අන්වර්ථ නාමය**: `rules` (අන්වර්ථ නාමයක් නැත) --- #### 2. `cost` / `eco` — අඩුම මිලැති සෞඛ්ය සම්පන්න සැපයුම්කරු අපේක්ෂක සංචිතය `costPer1MTokens` අනුව (ආරෝහණ අනුපිළිවෙළින්) වර්ග කර අඩුම මිලැති එක තෝරයි. පළමුව `OPEN` අපේක්ෂකයන් පෙරා ඉවත් කරයි. ```ts class CostStrategyImpl implements RouterStrategy { readonly name = "cost"; readonly description = "Always selects cheapest available provider"; select(pool, context) { const healthy = pool.filter((c) => c.circuitBreakerState !== "OPEN"); const sorted = [...healthy].sort((a, b) => a.costPer1MTokens - b.costPer1MTokens); return { provider: sorted[0].provider /* ... */ }; } } ``` **භාවිත කළ යුත්තේ කවදාද**: පිරිවැයට සංවේදී වැඩ බර, කණ්ඩායම් සැකසුම් හෝ පසුබිම් කාර්යයන් සඳහා. **අන්වර්ථ නාම**: `cost`, `eco` --- #### 3. `latency` / `fast` — විශ්වසනීයත්ව දඬුවමක් සමඟ අඩුම p95 ප්රමාදය `p95LatencyMs + (errorRate * 1000)` අනුව වර්ග කරයි. දෝෂ අනුපාත දඬුවම නිසා නාමික ප්රමාදය අඩු වුවද විශ්වසනීය නොවන සැපයුම්කරුවන් පහළින් ශ්රේණිගත වේ. ```ts class LatencyStrategyImpl implements RouterStrategy { readonly name = "latency"; readonly description = "Prioritizes lowest p95 latency with reliability weighting"; select(pool, context) { const healthy = pool.filter((c) => c.circuitBreakerState !== "OPEN"); const sorted = [...healthy].sort( (a, b) => a.p95LatencyMs + a.errorRate * 1000 - (b.p95LatencyMs + b.errorRate * 1000) ); return { provider: sorted[0].provider /* ... */ }; } } ``` **භාවිත කළ යුත්තේ කවදාද**: තත්ය කාලීන chat, autocomplete හෝ අන්තර්ක්රියාකාරී coding assistants වැනි ප්රමාදයට සංවේදී වැඩ බර සඳහා. **අන්වර්ථ නාම**: `latency`, `fast` --- #### 4. `sla-aware` / `sla` — ප්රමාද/දෝෂ/පිරිවැය SLO අනුකූලතාව වින්යාස කළ SLO ප්රතිපත්තිය එක් එක් අපේක්ෂකයා කෙතරම් හොඳින් සපුරාලන්නේද යන්න අනුව ලකුණු ලබා දෙයි: | සාධකය | බර | සූත්රය | | ------------- | --- | --------------------------------------------------- | | ප්රමාද ලකුණ | 35% | `threshold / max(value, ε)` | | දෝෂ ලකුණ | 35% | `threshold / max(value, ε)` | | සෞඛ්ය ලකුණ | 15% | `1.0` (CLOSED) / `0.5` (HALF_OPEN) / `0.0` (OPEN) | | පිරිවැය ලකුණ | 10% | `threshold / max(value, ε)` හෝ ප්රතිලෝම සාමාන්යකරණය | | ස්ථායිතා ලකුණ | 5% | ප්රමාද සම්මත අපගමනයේ ප්රතිලෝම සාමාන්යකරණය | `hardConstraints: true` වන විට, අපේක්ෂකයන් ප්රථමයෙන් **උල්ලංඝන ලකුණ** (ඔවුන් යම් SLO එකක් කොපමණ ඉක්මවන්නේද යන්න) අනුවද, පසුව සංයුක්ත ලකුණ අනුවද අනුපිළිවෙළට සකසනු ලැබේ. එසේ නොමැති විට, සංයුක්ත ලකුණ පමණක් භාවිත වේ. ```ts class SLAStrategyImpl implements RouterStrategy { readonly name = "sla-aware"; readonly description = "Selects the provider most likely to satisfy latency, error-rate, and cost SLOs"; select(pool, context) { // ... ප්රතිපත්තියට සාපේක්ෂව එක් එක් අපේක්ෂකයාට ලකුණු ලබා දෙයි: { targetP95Ms, maxErrorRate, maxCostPer1MTokens, hardConstraints } } } ``` **SLA ක්ෂේත්ර** (combo වින්යාසය මත සකසන්න): ```json { "strategy": "auto", "config": { "routerStrategy": "sla-aware", "slaTargetP95Ms": 1500, "slaMaxErrorRate": 0.05, "slaMaxCostPer1MTokens": 5, "slaHardConstraints": true } } ``` **භාවිත කළ යුත්තේ කවදාද**: දැඩි ප්රමාද, දෝෂ අනුපාත හෝ පිරිවැය අයවැය සහිත නිෂ්පාදන කාර්යභාර සඳහා. **අන්වර්ථ නාම**: `sla-aware`, `sla` --- #### 5. `lkgp` — අවසන් වරට හොඳ බව දන්නා සැපයුම්කරු පළමුව **අවසන් වරට හොඳ බව දන්නා සැපයුම්කරු** (සකසා ඇත්නම්) පළමුව උත්සාහ කර, පසුව `rules` උපායමාර්ගය වෙත ආපසු යයි. සැසි අනුබද්ධතාව සඳහා මෙය ප්රයෝජනවත්ය — සංවාදයක පසු විමසුම් එකම සැපයුම්කරු විසින් හසුරුවනු ලැබේ. ```ts class LKGPStrategyImpl implements RouterStrategy { readonly name = "lkgp"; readonly description = "Tries last known good provider first, then falls back to rules"; select(pool, context) { if (context.lkgpEnabled === false) { return getStrategy("rules").select(pool, context); } if (context.lastKnownGoodProvider) { const candidates = pool.filter( (c) => c.provider === context.lastKnownGoodProvider && c.circuitBreakerState !== "OPEN" ); if (candidates.length > 0) { return { provider: candidates[0].provider /* ... */ }; } } // rules උපායමාර්ගය වෙත ආපසු යන්න return getStrategy("rules").select(pool, context); } } ``` **භාවිත කළ යුත්තේ කවදාද**: පසු විමසුම් එකම සැපයුම්කරු විසින් හසුරුවනු ලැබීමට ඔබට අවශ්ය බහු-වාර සංවාද සඳහා (උදා., හැඹිලිගත කිරීම, සන්දර්භ අඛණ්ඩතාව හෝ මිලකරණ අනුකූලතාව සඳහා). **අන්වර්ථ නාමය**: `lkgp` (අන්වර්ථ නාමයක් නැත) --- #### 6. `nadir` — Nadir හරහා prompt-සංවේදී ආකෘති තේරීම ඉහත සෑම උපායමාර්ගයක්ම අපේක්ෂකයන් ශ්රේණිගත කරන්නේ තමන්ගේම telemetry මත පදනම්වය; ඒ කිසිවක් ඉල්ලීම කියවන්නේ නැත. `nadir` විසින් අවසන් පරිශීලක වාරය සහ pool එකේ model ids, [Nadir](https://getnadir.com) හි තීරණ API එකට (`POST /v1/bucket`) යවා එම මෙනුවෙන් Nadir තෝරන ආකෘතිය වෙත route කරයි (`simple` → හැකියාව ඇති අඩුම මිල ආකෘතිය, `complex` → frontier ආකෘතිය). එම ආකෘතිය සපයන සම්බන්ධතාව තවමත් `rules` මඟින් තෝරනු ලබන බැවින් quota, සෞඛ්යය සහ පිරිවැය දිගටම කුමන ගිණුම තෝරාගන්නේද යන්න තීරණය කරයි. ```json { "strategy": "auto", "config": { "routerStrategy": "nadir", "nadir": { "apiKey": "ndr_...", "baseUrl": "https://api.getnadir.com", "timeoutMs": 2000 } } } ``` මෙම string දෙක සඳහා env fallback ලෙස `OMNIROUTE_NADIR_API_KEY` සහ `OMNIROUTE_NADIR_BASE_URL` භාවිත වේ. `baseUrl` අවශ්ය වන්නේ ස්වයං-සත්කාරක Nadir එකක් සඳහා පමණි (අගට ඇති `/v1` පිළිගනු ලැබේ). යතුරක් රහිත ඇමතුම් Nadir හි නිර්නාමික tier එකට යොමු වන අතර, එය IP එකකට rate-limit කර ඇත. පද්ධතියෙන් පිටතට යන දෑ: අවසන් පරිශීලක පණිවිඩයේ පෙළ (පළමු අක්ෂර 16k), අපේක්ෂක model ids සහ `source: "omniroute"` channel tag එකක්. system prompt, ඉතිහාසය, මෙවලම් හෝ headers කිසිවක් නොයැවේ. අසාර්ථක හැසිරීම fail-open වේ: timeout එකක් (පෙරනිමිය 2000 ms), non-2xx ප්රතිචාරයක්, ළඟා විය නොහැකි host එකක්, විකෘති ප්රතිචාරයක් හෝ pool එකෙන් පිටත තේරීමක් ඇති වූ විට `rules` තීරණය භාවිත වන අතර හේතුවට `NadirStrategy: fallback (…)` යන උපසර්ගය එක් කෙරේ. අසාර්ථක ඇමතුමකින් පසු උපායමාර්ගය තත්පර 30ක් ජාලය මඟහරින බැවින්, බිඳවැටීමකදී සෑම ඉල්ලීමකටම එක timeout එකක් වෙනුවට තත්පර 30කට එක timeout එකක් පමණක් වැය වේ. Routing events මඟින් `strategy: "nadir"` වාර්තා කරන්නේ Nadir සැබවින්ම තේරීම සිදු කළ විට පමණි. **භාවිත කළ යුත්තේ කවදාද**: ආකෘති tiers කිහිපයක් ආවරණය කරන pool එකක (කුඩා, මධ්යම සහ frontier ආකෘතියක්) මිශ්ර දුෂ්කරතා සහිත traffic සඳහා, සෑම විටම frontier ආකෘතිය භාවිත කිරීමේ පිරිවැය අඩු කිරීමට අවශ්ය විට. **අන්වර්ථ නාමය**: `nadir` (අන්වර්ථ නාමයක් නැත) --- ### අභිරුචි router උපායමාර්ග පොදු API එක හරහා ඔබේම `RouterStrategy` implementation එකක් ලියාපදිංචි කළ හැකිය: ```ts import { registerStrategy, type RouterStrategy, } from "@omniroute/open-sse/services/autoCombo/routerStrategy"; class MyCustomStrategy implements RouterStrategy { readonly name = "my-custom"; readonly description = "My custom routing strategy"; select(pool, context) { // ඔබේ routing තර්කනය මෙහි ඇතුළත් කරන්න return { provider: pool[0].provider, model: pool[0].model, strategy: this.name, reason: "MyCustomStrategy: ...", candidatesConsidered: pool.length, finalScore: 1.0, }; } } registerStrategy("my-custom", new MyCustomStrategy()); ``` ඉන්පසු එය භාවිත කරන්න: ```json { "strategy": "auto", "config": { "routerStrategy": "my-custom" } } ``` --- ### Router උපායමාර්ග තේරීමේ මාර්ගෝපදේශය | භාවිත අවස්ථාව | උපායමාර්ගය | හේතුව | | ----------------- | ----------- | ------------------------------------------ | | සමතුලිත කාර්යභාරය | `rules` | පෙරනිමිය — සියලු සාධක සලකා බලයි | | පිරිවැය අවම කිරීම | `cost` | සෑම විටම අඩුම මිල විකල්පය තෝරයි | | ප්රමාදය අවම කිරීම | `latency` | වේගවත්ම විශ්වාසදායක සැපයුම්කරු තෝරයි | | දැඩි SLOs | `sla-aware` | p95/දෝෂ/පිරිවැය සීමා අනුව පෙරහන් කරයි | | බහු-වාර කතාබහ | `lkgp` | සැසි අනුබද්ධතාව | | මිශ්ර දුෂ්කරතාව | `nadir` | එක් එක් prompt එක අනුව model tier එක තෝරයි | SLA-aware ක්ෂේත්ර: ```json { "strategy": "auto", "config": { "routerStrategy": "sla-aware", "slaTargetP95Ms": 1500, "slaMaxErrorRate": 0.05, "slaMaxCostPer1MTokens": 5, "slaHardConstraints": true } } ``` ## කාර්ය යෝග්යතාව කාර්ය වර්ග 6ක් (`coding`, `review`, `planning`, `analysis`, `debugging`, `documentation`) හරහා ආකෘති 30කට වැඩි සංඛ්යාවක් ලකුණු කර ඇත. Wildcard රටා සඳහා සහාය දක්වයි (උදා., `*-coder` → ඉහළ coding ලකුණක්). ## Auto ප්රභේද සාරාංශය හිස් `auto` (පෙරනිමි) සහ `autoPrefix.ts` තුළ ප්රකාශිත `AutoVariant` අගයන් 6 ඇතුළුව, **කැඳවිය හැකි model ID 7ක්** ඇත: `auto`, `auto/coding`, `auto/fast`, `auto/cheap`, `auto/offline`, `auto/smart`, `auto/lkgp` (`AutoVariant` විසින්ම අගයන් 6ක් ලැයිස්තුගත කරයි; 7 වන විකල්පය "ප්රභේදයක් නැත" යන්නයි — හිස් `auto` — එය `parseAutoPrefix()` මඟින් `variant: undefined` ලෙස හසුරුවයි.) ## Auto-Combo සමඟ ස්තර ගැළපෙන ආකාරය සාධක 16ක ලකුණුකරණ ශ්රිතය (`open-sse/services/autoCombo/scoring.ts`) ස්තර සාමාජිකත්වය සංඥා දෙකක් ලෙස සලකයි: `tierPriority` (0.0476) සහ `tierAffinity` (0.0476). සම්පූර්ණ `DEFAULT_WEIGHTS` කට්ටලය සඳහා ඉහත ඇති සම්මත [ලකුණුකරණ සාධක වගුව](#how-it-works-persisted-auto-combos) බලන්න — එක් එක් පැකේජයට අදාළ අතික්රමණ (ship-fast/cost-saver/quality-first/ offline-friendly) "එක් එක් පැකේජය සඳහා බර පැතිකඩ" වගුවේ දක්වා ඇත. ස්තරය පමණක් **Tier 1** පළමුව තැබීමට බල නොකරයි — Tier 1 ප්රමාදය අයහපත් නම් හෝ පිරිවැයට සාපේක්ෂ ගුණාත්මකභාවය ප්රශස්ත නොවේ නම්, Tier 2 ජය ගනී. ස්තර අනුපිළිවෙළ බලෙන් යෙදීමට, `priority` සංයෝජන උපායමාර්ගය භාවිත කර සැපයුම්කරුවන් ස්තරය අනුව සකසන්න. Tier 1 (දායකත්වය) දැඩි ලෙස ප්රිය කිරීමට, `tierPriority` බර වැඩි කරන්න: ```json { "strategy": "auto", "config": { "auto": { "weights": { "tierPriority": 0.3, "costInv": 0.05 } } } } ``` ස්තර නිර්වචන සහ සැපයුම්කරු වර්ගීකරණය සඳහා [`docs/guides/TIERS.md`](../guides/TIERS.md) බලන්න. ## පරීක්ෂණ සහ ආවරණය ### නිශ්චිත routing-තීරණ අනුකෘතිය (`npm run test:combo:matrix`) `tests/integration/combo-matrix/*.test.ts` විසින් mock කළ upstream එකක් සමඟ සැබෑ combo pipeline එක හරහා පොදු උපායමාර්ග 19ම සඳහා routing **තීරණය** ආරම්භයේ සිට අවසානය දක්වා තහවුරු කරයි. ආවරණයට පහත දෑ ඇතුළත් වේ: - `ROUTING_STRATEGY_VALUES` උපායමාර්ග 19ම (ordered, weighted, cost, context, fusion, …). - `quota-share` (අභ්යන්තර) ආරම්භයේ සිට අවසානය දක්වා: සැබෑ `selectQuotaShareTarget` seam එක (`registerQuotaFetcher` / `setLKGP` / `__setHeadroomSaturationFetcherForTests`) හරහා DRR සාධාරණත්වය + සංතෘප්ති ප්රමුඛතාව අඩු කිරීම. - සෑම target සංඛ්යාවක් පුරාම `context-relay` සාර්වත්රික-handoff ආවරණය. මෙම suite එක CI තුළ (`test:integration` job) `--test-concurrency=1` සහ `--test-force-exit` සමඟ ධාවනය වන බැවින් එය නිශ්චිත වන අතර සජීවී අක්තපත්ර අවශ්ය නොවේ. ### Gated සජීවී smoke පරීක්ෂණ (CI තුළ නොවේ — සැබෑ සපයන්නන්) | විධානය | එයින් සිදු වන්නේ කුමක්ද | | :------------------------------------- | :--------------------------------------------------------------------------------------- | | `npm run test:combo:live` | `RUN_COMBO_LIVE=1` සමඟ in-process සැබෑ routing; සජීවී OmniRoute DB එකක snapshot එකක් ගනී | | `npm run test:combo:live:vps` | සජීවී OmniRoute server එකකට එරෙහි HTTP calls (`COMBO_LIVE_BASE_URL` සකසන්න) | | `npm run test:combo:live:vps:failover` | එයම, හිතාමතා සැලසුම් කළ failover අවස්ථා සමඟ | මෙම smoke පරීක්ෂණ සැබෑ wire මාර්ගය (combo → provider → completion) ක්රියාත්මක කරයි. ඒවාට සජීවී අක්තපත්ර සහ VPS ප්රවේශය අවශ්ය වන බැවින්, හිතාමතාම CI වෙතින් බැහැර කර ඇත. --- ## ගොනු | ගොනුව | අරමුණ | | :-------------------------------------------------------- | :------------------------------------------------------------------------------------------------------------------------------- | | `open-sse/services/autoCombo/scoring.ts` | සාධක 16ක ලකුණු කිරීමේ ශ්රිතය, `DEFAULT_WEIGHTS`, සංචිත සාමාන්යකරණය | | `open-sse/services/autoCombo/taskFitness.ts` | Model × කාර්ය යෝග්යතා සෙවීම | | `open-sse/services/autoCombo/engine.ts` | තේරීමේ තර්කනය, bandit, අයවැය සීමාව | | `open-sse/services/autoCombo/selfHealing.ts` | බැහැර කිරීම, පරීක්ෂණ, සිදුවීම් ප්රකාරය | | `open-sse/services/autoCombo/modePacks.ts` | බර පැතිකඩ 6ක් (වේගයෙන්-නිකුත්-කිරීම, පිරිවැය-ඉතිරිකිරීම, ගුණාත්මකභාවය-පළමුව, නොබැඳි-හිතකාමී, විශ්වසනීයත්වය-පළමුව, අවුල්-ප්රකාරය) | | `open-sse/services/autoCombo/autoPrefix.ts` | `auto/` උපසර්ග විග්රහකය + ප්රභේද 6ක් | | `open-sse/services/autoCombo/virtualFactory.ts` | සජීවී සම්බන්ධතාවලින් මතකය තුළ `AutoComboConfig` ගොඩනඟයි | | `open-sse/services/autoCombo/providerRegistryAccessor.ts` | සැපයුම්කරු රෙජිස්ට්රිය අනුකරණය කිරීම සඳහා පරීක්ෂණ සම්බන්ධකය | | `src/shared/constants/routingStrategies.ts` | `ROUTING_STRATEGY_VALUES` (උපායමාර්ග 20ක්) | | `src/sse/handlers/chat.ts` | ඒකාබද්ධ කිරීම: auto-prefix කෙටි-පරිපථනය |