API Reference (Հայերեն)

September 23, 2026 · View on GitHub

🌐 Languages: 🇺🇸 English · 🇪🇹 am · 🇸🇦 ar · 🇦🇿 az · 🇧🇬 bg · 🇧🇩 bn · 🇧🇦 bs · 🇨🇿 cs · 🇩🇰 da · 🇩🇪 de · 🇬🇷 el · 🇪🇸 es · 🇪🇪 et · 🇮🇷 fa · 🇫🇮 fi · 🇫🇷 fr · 🇮🇪 ga · 🇮🇳 gu · 🇳🇬 ha · 🇮🇱 he · 🇮🇳 hi · 🇭🇷 hr · 🇭🇺 hu · 🇮🇩 id · 🇳🇬 ig · 🇮🇹 it · 🇯🇵 ja · 🇬🇪 ka · 🇰🇭 km · 🇮🇳 kn · 🇰🇷 ko · 🇱🇹 lt · 🇱🇻 lv · 🇮🇳 ml · 🇮🇳 mr · 🇲🇾 ms · 🇲🇹 mt · 🇲🇲 my · 🇳🇵 ne · 🇳🇱 nl · 🇳🇴 no · 🇮🇳 or · 🇮🇳 pa · 🇵🇭 phi · 🇵🇱 pl · 🇵🇹 pt · 🇧🇷 pt-BR · 🇷🇴 ro · 🇷🇺 ru · 🇱🇰 si · 🇸🇰 sk · 🇸🇮 sl · 🇷🇸 sr · 🇸🇪 sv · 🇰🇪 sw · 🇮🇳 ta · 🇮🇳 te · 🇹🇭 th · 🇹🇷 tr · 🇺🇦 uk-UA · 🇵🇰 ur · 🇺🇿 uz · 🇻🇳 vi · 🇳🇬 yo · 🇨🇳 zh-CN · 🇹🇼 zh-TW

OmniRoute API-ի հիմնական տեղեկատու։ Այն ընդգրկում է հանրային /v1 մակերեսը և կառավարման առավել հաճախ օգտագործվող վերջնակետերը. մեքենայաընթեռնելի docs/openapi.yaml-ը և src/app/api/-ի տակ գտնվող երթուղիների ծառը սպառիչ աղբյուրներն են։

Բովանդակություն

Զրույցի լրացումներ
Բացառիկ կառավարվող աշխատաշրջանների վարձակալություններ
Ներդրումներ
Պատկերների ստեղծում
Փաստաթղթերի OCR
Մոդելների ցանկ
Մատակարարի փլագինի մանիֆեստ
Համատեղելիության վերջնակետեր
Ֆայլերի API
Փաթեթների API
Որոնման API
WebSocket հոսքային փոխանցում
Քվոտաների և խնդիրների հաղորդում
Իմաստաբանական քեշ
Կառավարման վահանակ և կառավարում
Համակցությունների կառավարում
Վեբհուքներ
Գրանցված բանալիներ (ինքնակառավարում)
Գործակալների արձանագրություն
Կառավարման պրոքսիներ
Դիմակայունություն (ընդլայնված)
Հմտություններ
Հիշողություն
MCP սերվեր
A2A սերվեր
Ամպ, գնահատումներ և արժևորում
Հարցումների մշակում
Նույնականացում

Զրույցի լրացումներ

POST /v1/chat/completions
Authorization: Bearer your-api-key
Content-Type: application/json

{
  "model": "cc/claude-opus-4-6",
  "messages": [
    {"role": "user", "content": "Write a function to..."}
  ],
  "stream": true
}

Հատուկ վերնագրեր

Վերնագիր	Ուղղություն	Նկարագրություն
`X-OmniRoute-No-Cache`	Հարցում	Քեշը շրջանցելու համար սահմանեք `true`
`x-omniroute-no-memory`	Հարցում	Այս հարցման համար հիշողության և հմտությունների ներարկումը բաց թողնելու նպատակով սահմանեք `true` (արտացոլում է no-cache-ը և խուսափում յուրաքանչյուր կանչի տոկենների/արժեքի լրացուցիչ ծախսից)
`X-OmniRoute-Progress`	Հարցում	Առաջընթացի իրադարձությունների համար սահմանեք `true`
`X-Session-Id`	Հարցում	Կպչուն աշխատաշրջանի բանալի՝ արտաքին աշխատաշրջանային համապատասխանության համար
`x_session_id`	Հարցում	Ընդունվում է նաև ընդգծման նշանով տարբերակը (ուղղակի HTTP)
`X-OmniRoute-Session-Id`	Հարցում	Կանչող կողմի տրամադրած աշխատաշրջանի/զրույցի պիտակ (նաև փոխանցվում է հիշողությանը)։ Առկայության դեպքում անփոփոխ պահպանվում է `call_logs.session_tag`-ում՝ ըստ աշխատաշրջանի ծախսերի վերագրման համար (#8249), իսկ բացակայության դեպքում երբեք չի սինթեզվում
`Idempotency-Key`	Հարցում	Կրկնօրինակների վերացման բանալի (5 վրկ պատուհան)
`X-Request-Id`	Հարցում	Կրկնօրինակների վերացման այլընտրանքային բանալի
`X-OmniRoute-Cache`	Պատասխան	`HIT` կամ `MISS` (ոչ հոսքային)
`X-OmniRoute-Idempotent`	Պատասխան	`true`, եթե կրկնօրինակը հեռացվել է
`X-OmniRoute-Progress`	Պատասխան	`enabled`, եթե առաջընթացի հետագծումը միացված է
`X-OmniRoute-Session-Id`	Պատասխան	OmniRoute-ի կողմից օգտագործված արդյունավետ աշխատաշրջանի ID-ն
`X-OmniRoute-Request-Id`	Պատասխան	Հարցման փոխկապակցման id-ն (երբ հայտնի է)
`X-OmniRoute-Version`	Պատասխան	OmniRoute-ի կառուցման տարբերակը (միշտ առկա է)
`X-OmniRoute-Cost-Saved`	Պատասխան	USD-ով այն գումարը, որը քեշի շնորհիվ չի ծախսվել HIT-ի դեպքում (միայն քեշի համընկնումների համար)
`X-OmniRoute-Decision`	Պատասխան	Ուղղորդման հետագիծ՝ `strategy=<name>; provider=<alias>; latency_ms=<n>` (`<name>`-ը համակցման ռազմավարությունն է, իսկ ոչ համակցված հարցման դեպքում՝ `single`) — ավարտման պատասխաններում միշտ առկա է

Nginx-ի նշում․ եթե հիմնվում եք ընդգծման նշան պարունակող վերնագրերի վրա (օրինակ՝ x_session_id), միացրեք underscores_in_headers on;։

Ծախսերի հեռաչափության վերնագրեր. առանց հոսքային փոխանցման հաջող պատասխանները նույնպես պարունակում են ծախսերի հեռաչափության X-OmniRoute-* հավաքածուն՝ X-OmniRoute-Response-Cost (USD, ֆիքսված 10 տասնորդական նիշով, իսկ անվճար/չգնահատված լինելու դեպքում՝ 0.0000000000), X-OmniRoute-Tokens-In / X-OmniRoute-Tokens-Out, X-OmniRoute-Model, X-OmniRoute-Provider, X-OmniRoute-Latency-Ms, X-OmniRoute-Cache-Hit և X-OmniRoute-Fallback-Attempts (միայն երբ > 0), ինչպես նաև X-OmniRoute-Request-Id և X-OmniRoute-Version։ Դրանք վերադարձվում են զրույցի լրացումների, /v1/responses, /v1/messages, ինչպես նաև մեդիայի վերջնակետերի կողմից՝ /v1/embeddings, /v1/images/generations, /v1/audio/speech, /v1/audio/transcriptions, /v1/rerank, /v1/videos/generations, /v1/music/generations և /v1/moderations (ծախսը միշտ 0 է)։ Մեդիայի ծախսը հաշվարկվում է ըստ մոդալության (յուրաքանչյուր պատկերի, վայրկյանի, նիշի կամ որոնման միավորի համար), երբ գնագոյացումը հասանելի է, իսկ հակառակ դեպքում՝ 0 (fail-open)։

Քեշի համընկնման ծախսային իմաստաբանություն. իմաստային քեշում համընկնման դեպքում (X-OmniRoute-Cache-Hit: true) վերին հոսքի կանչ չի կատարվում, ուստի X-OmniRoute-Response-Cost-ը 0.0000000000 է (համընկնումը սպասարկելու հավելաճային ծախսը)։ Սկզբնական/հակառակ դեպքում առաջանալիք ծախսն առանձին հաղորդվում է X-OmniRoute-Cost-Saved-ում։ Վճարումների հաշվառման համակարգերը պետք է գումարեն X-OmniRoute-Response-Cost-ը (համընկնումները ոչինչ չեն արժենում), իսկ քեշի վերլուծական համակարգերը կարող են ագրեգացնել X-OmniRoute-Cost-Saved-ը։

Բացառիկ կառավարվող նիստի վարձակալություններ

Բացառիկ կառավարվող նիստի վարձակալությունը ընտրովի, հաճախորդից անկախ երթուղային պայմանագիր է. մեկ ակտիվ սեփականատերն ունի մեկ համապատասխան OmniRoute կապ: Այն չի վարձակալում մոդել, չի պահանջում OAuth, չի նույնացնում որոշակի հաճախորդ կամ չի պահանջում որոշակի մատակարար:

Նույնականացնող API բանալին պետք է ունենա lease:exclusive տիրույթ և բացահայտ ոչ դատարկ allowedConnections ցուցակ: Տվյալների բազայի փոփոխության սահմանը կիրառում է երկու դաշտերը միասին բանալու ստեղծման և մասնակի թարմացումների ժամանակ:

POST /api/v1/session-leases
Authorization: Bearer <managed-api-key>
Content-Type: application/json
X-OmniRoute-Lease-Owner: vlo_<43-base64url-characters>

{"action":"acquire","model":"glm/glm-4.6"}

Հաջող ձեռքբերման, թարմացման և թողարկման պատասխանները բացահայտում են ժամանակի դրոշմները, state-ը և ճշգրիտ դրական generation-ը, բայց երբեք ընտրված կապը կամ հավատարմագրերը: Թարմացումը և թողարկումը մատակարարում են սերունդը JSON մարմնում:

{ "action": "renew", "generation": 1 }

{ "action": "release", "generation": 1, "reason": "OWNER_EXIT" }

Ակտիվ վարձակալության սեփականատերը կարող է բացահայտորեն պահանջել գաղտնիության համար անվտանգ ցուցադրման մետատվյալներ իր ընթացիկ կապի համար.

{ "action": "status", "generation": 1 }

{
  "state": "ACTIVE",
  "generation": 1,
  "acquiredAt": "2026-08-28T12:00:00.000Z",
  "renewedAt": "2026-08-28T12:00:30.000Z",
  "expiresAt": "2026-08-28T12:02:30.000Z",
  "connection": {
    "displayName": "Primary Codex",
    "provider": "codex"
  }
}

Այս ընտրովի կարգավիճակի գործողությունը պաշտպանված է անթափանց սեփականատիրոջ, նույնականացված կառավարվող API բանալու և ճշգրիտ ակտիվ սերնդի կողմից մեկ տվյալների բազայի գործարքի շրջանակներում: displayName-ը միայն կտրված կոնֆիգուրացված կապի անունն է. այն null է, երբ անվտանգ կոնֆիգուրացված անուն գոյություն չունի: OmniRoute-ը երբեք չի փոխարինում էլ. փոստի կամ ստեղծված հաշվի նույնականացումը: Մատակարարի արժեքը ոչ զգայուն ցուցադրման պիտակ է և երբեք ստեղծված համատեղելի մատակարարի նույնականացուցիչ չէ: Հավատարմագրերը, թոքենները, քուքիները, հում կապի կամ API բանալու ID-ները, սեփականատիրոջ հեշերը, պաշտպանության գաղտնիքները և ներքին երթուղային տվյալները բացառվում են:

Սխալ բանալու, սխալ սեփականատիրոջ, հնացած սերնդի, բացակայող, ժամկետանց, թողարկված և անվավերացված որոնումները բոլորը վերադարձնում են նույն 409 LEASE_FENCE_STALE սխալը՝ առանց կապի մետատվյալների: Հաճախորդը, որը ստացել է հզորության սպասման պատասխանը, չունի ակտիվ կապ՝ ստուգելու համար: Երբ երթուղին փոխանցում է ակտիվ վարձակալություն, նույն սերունդը մնում է վավեր, և կարգավիճակը ատոմային կերպով վերադարձնում է նոր կապը, երբեք հինը: Գոյություն ունեցող հաճախորդները մնում են անփոփոխ, քանի որ ձեռքբերման, թարմացման, թողարկման և սպասման պատասխանները պահպանում են իրենց նախորդ ձևերը:

Այս սերվերի պայմանագիրը չի փոխում սովորական OpenAI Codex /status-ը: Սովորական Codex-ը ներկայումս հաղորդում է իր մոդելի մատակարարին և ներկառուցված նույնականացման/հաշվի վիճակը, բայց չի ցուցադրում կամայական հատուկ մատակարարի հաշվի մետատվյալներ. ավելի ուշ հաճախորդի ինտեգրումը պետք է կանչի այս գործողությունը և որոշի, թե ինչպես ցուցադրել connection.displayName-ը:

Յուրաքանչյուր կառավարվող եզրակացության հարցում այնուհետև մատակարարում է երկու կառավարման վերնագրեր.

X-OmniRoute-Lease-Owner: vlo_<43-base64url-characters>
X-OmniRoute-Lease-Generation: 1

Ճշգրիտ սեփականատերը, սերունդը, ակտիվ կապը և նույնականացված API բանալին պաշտպանված են անմիջապես յուրաքանչյուր աջակցվող վերին հոսքի փորձից առաջ: Սեփականատիրոջ և սերնդի վերարտադրումը մեկ այլ բանալիով ձախողվում է նույնիսկ այն դեպքում, երբ այդ բանալին թույլ է տալիս նույն կապը: Հում սեփականատերերը չեն պահպանվում, չեն գրանցվում, չեն պահվում հարցման լուսանկարում կամ չեն փոխանցվում վերին հոսք:

Ժամանակավոր վիճաբանությունը վերադարձնում է HTTP 429 Retry-After-ով և.

{
  "state": "WAITING_FOR_CAPACITY",
  "error": { "type": "lease_error", "code": "LEASE_CAPACITY_UNAVAILABLE" },
  "reason": "NO_FREE_ELIGIBLE_CONNECTION",
  "retryAfter": 30
}

Այս պատասխանը միայն նշանակում է, որ սովորական համապատասխանող հավաքածուն ոչ դատարկ էր, և յուրաքանչյուր ազատ թեկնածու պահվում էր օտար ակտիվ վարձակալության կողմից: Անաջակցվող մոդելները/մատակարարները, քաղաքականության անհամապատասխանությունը, սառեցումը, քվոտան, առողջությունը և այլ սովորական համապատասխանության ձախողումները պահպանում են իրենց գոյություն ունեցող OmniRoute պատասխանները:

`x-omniroute-compression`

Սեղմման պլանի յուրաքանչյուր հարցման վերագրում: Ամենաբարձր առաջնահերթությունը՝ գերազանցում է երթուղային-կոմբոյի վերագրումը, ակտիվ պրոֆիլը, ավտոմատ գործարկումը և վահանակի լռելյայնը: Արժեքներ.

Արժեք	Ազդեցություն
`off`	Այս հարցման համար սեղմում չկա:
`default`	Վահանակից ստացված լռելյայն պրոֆիլը (անտեսում է ակտիվ պրոֆիլը): Կորուստով շարժիչները անջատված են:
`safe`	Միայն կրկնօրինակում և բացատների ծալում:
`allow-lossy`	Պահպանել օպերատորի պլանը այս հարցման համար, ներառյալ ամփոփագրերը և ոճի վերագրումները:
`engine:<id>`	Մեկ շարժիչ, երբ միացված է, օրինակ՝ `engine:rtk`: Յուրաքանչյուր հարցման համար ընտրովի այդ շարժիչի համար:
`<combo>`	Անվանված կոմբո, որը համընկնում է անունով (առանց մեծատառերի) նախ, ապա ID-ով:

Նշումներ:

Անհայտ արժեքներն անտեսվում են (հարցումը երբեք չի մերժվում). լուծումը անցնում է սովորական օպերատորի առաջնահերթությանը:
Եթե մի քանի կոմբոներ ունեն նույն անունը, ապա վերջնական համընկնման համար փոխանցեք կոմբոյի ID-ն:
Կոմբոն, որի անունը off կամ default է, չի կարող ընտրվել անունով (այդ բանալի բառերը մեկնաբանվում են նախ); նման կոմբոյին հղում կատարեք դրա ID-ով:
Հիմնական սեղմման անջատիչը կոշտ դարպաս է. երբ սեղմումն անջատված է գլոբալ, այս վերնագիրը չի կարող այն միացնել:

Կիրառված պլանը արտացոլվում է պատասխան վերնագրում.

X-OmniRoute-Compression: <mode>; source=<source>

որտեղ <source>-ը request-header, routing-override, active-profile, auto-trigger, default կամ off է:

Ներդրումներ

POST /v1/embeddings
Authorization: Bearer your-api-key
Content-Type: application/json

{
  "model": "nebius/Qwen/Qwen3-Embedding-8B",
  "input": "The food was delicious"
}

Հասանելի պրովայդերներ՝ Nebius, OpenAI, Mistral, Together AI, Fireworks, NVIDIA, OpenRouter, Jina AI։

Կատալոգի նույնացուցիչներն ունեն provider/model ձևաչափը (օրինակ՝ jina-ai/jina-embeddings-v5-omni-small)։ Ռեեստրում առկա Jina մոդելների՝ առանց պրովայդերի նշման նույնացուցիչները (օրինակ՝ jina-embeddings-v5-text-small, jina-reranker-v3.5) նույնպես ճանաչվում են։ Jina-ի embed/rerank/classify/segment գործառույթները նախ օգտագործում են կառավարման վահանակի jina-ai հավատարմագրերը․ JINA_AI_API_KEY-ը պահուստային տարբերակ է միայն այն դեպքում, երբ կառավարման վահանակում բանալի չկա։ jina-reader քարտը նախատեսված է միայն Reader / r.jina.ai-ի համար (POST /v1/web/fetch) և երբեք չի սպասարկում ներդրումներ կամ վերադասակարգում։

Ռեեստրի այն մոդելները, որոնք նշում են բազմամոդալ աջակցության առկայությունը, նաև ընդունում են պրովայդերից անկախ՝ մինչև 32 կառուցվածքային տարր։ Մեդիա տարրերի տեսակներն են text, image, audio, video և document։ Դրանց մեդիա source-ը կամ {"type":"url","url":"https://..."} է, կամ {"type":"base64","data":"...","media_type":"..."}։

Jina v5 Omni-ն (jina-ai/jina-embeddings-v5-omni-small, jina-ai/jina-embeddings-v5-omni-nano և ընտանիքի կեղծանունը՝ jina-ai/jina-embeddings-v5-omni → omni-small) նաև ընդունում է Jina-ի բնիկ EmbeddingsV5Request փաստաթղթերը և դրանք անփոփոխ փոխանցում է https://api.jina.ai/v1/embeddings հասցեին․

{
  "model": "jina-ai/jina-embeddings-v5-omni-small",
  "task": "retrieval.query",
  "normalized": true,
  "input": [
    { "text": "a red bicycle" },
    { "image": "https://example.com/bike.png" },
    {
      "content": [{ "text": "caption" }, { "image": "data:image/png;base64,..." }]
    }
  ]
}

Բնիկ { image | audio | video | pdf } արժեքները կարող են լինել հանրային HTTPS URL, data: URI կամ չմշակված base64։ OmniRoute-ը չի փոխակերպում այդ օբյեկտները տողերի և չի ներբեռնում բնիկ պատկերի URL-ները․ Jina-ն ինքն է ստանում հանրային մեդիան։ Jina-ի լրացուցիչ դաշտերը (task, normalized, truncate, embedding_type) փոխանցվում են։ Միայն տեքստի համար նախատեսված Jina SKU-ները նախկինի պես մերժում են ոչ տեքստային փաստաթղթերը։

Անվտանգության և փոխանցման սահմանափակումներ․

Հեռակա մեդիայի URL-ները պետք է լինեն հանրային HTTPS։ Կանոնական {type,source:url} տարրերը ներբեռնվում են սերվերի կողմից (վերահղումների կրկնակի վավերացում, ժամանակի սահմանափակում, չափի սահմանափակումներ, հանրային DNS, կապի ամրագրում) և ներդրվում են նախքան պրովայդերի կանչը։ Jina-ի բնիկ {image:"https://..."} տարրերը փոխանցվում են անփոփոխ նույն հանրային HTTPS ստուգումից հետո․ Jina-ն ներբեռնում է URL-ը։
Ներդրված base64 մեդիայի ապակոդավորված չափը սահմանափակված է մինչև 8 MiB յուրաքանչյուր տարրի համար և մինչև 16 MiB ամբողջ հարցման համար։

Փոխակերպում ըստ պրովայդերի (կանոնական տարրերը երբեք անփոփոխ չեն փոխանցվում)․

Jina-ի բազմամոդալ մոդելներ․ վերին մակարդակի յուրաքանչյուր տարր դառնում է մոդալության բանալիով մեկ օբյեկտ (text / image / audio / video / pdf)՝ ներդրված մեդիայի համար օգտագործելով data URI-ներ․ մեկ վեկտոր՝ վերին մակարդակի յուրաքանչյուր տարրի համար։
Gemini Embedding 2 ընտանիք․ վերին մակարդակի մեկ զանգվածը դառնում է մեկ բնիկ models/{model}:embedContent հարցում՝ content.parts-ով (text կամ inline_data)։
Անհայտ/դինամիկ մոդելները, որոնք չունեն մոդալության հստակ մետատվյալներ, մերժում են կառուցվածքային մուտքագրումը HTTP 400 կոդով։

{
  "model": "jina-ai/jina-embeddings-v5-omni-small",
  "input": [
    { "type": "text", "text": "A red bicycle" },
    {
      "type": "image",
      "source": { "type": "url", "url": "https://example.com/bicycle.png" }
    }
  ],
  "dimensions": 512,
  "encoding_format": "float"
}

Չաջակցվող մոդել/մոդալություն համակցությունները վերադարձնում են HTTP 400՝ տարրը հարկադրաբար փոխակերպելու փոխարեն։ Ոչ մուտքային ընդլայնման դաշտերը հին տողային/թոքենային հարցումներում շարունակում են փոխանցվել անփոփոխ։

# Թվարկել ներդրման բոլոր մոդելները
GET /v1/embeddings

Պատկերների գեներացում

POST /v1/images/generations
Authorization: Bearer your-api-key
Content-Type: application/json

{
  "model": "openai/gpt-image-2",
  "prompt": "A beautiful sunset over mountains",
  "size": "1024x1024"
}

Հասանելի մատակարարներ՝ OpenAI (GPT Image 2), xAI (Grok Image), Together AI (FLUX), Fireworks AI, Nebius (FLUX), Hyperbolic, NanoBanana, OpenRouter, SD WebUI (տեղային), ComfyUI (տեղային)։

# Թվարկել պատկերների բոլոր մոդելները
GET /v1/images/generations

Փաստաթղթերի OCR

POST /v1/ocr
Authorization: Bearer your-api-key
Content-Type: application/json

{
  "model": "mistral/mistral-ocr-latest",
  "document": {
    "type": "document_url",
    "document_url": "https://example.com/invoice.pdf"
  }
}

model-ը ընտրում է OCR մատակարարին՝ օգտագործելով provider/model նախածանցը․ միայն մոդելի նույնացուցիչը (օրինակ՝ mistral-ocr-latest) համապատասխանեցվում է իր գրանցված մատակարարին, իսկ բաց թողնված model-ի դեպքում լռելյայն օգտագործվում է Mistral-ը (mistral-ocr-latest)։ Գրանցված մատակարարներ (open-sse/config/ocrRegistry.ts)՝

Մատակարարի id	Մոդելի id	`model`-ի արժեքը	Նշումներ
`mistral`	`mistral-ocr-latest`	`mistral/mistral-ocr-latest` (կամ միայն `mistral-ocr-latest`)	Սինքրոն՝ պատասխանը վերադարձվում է անմիջապես վերին հոսքի մեկ կանչից։
`azure-document-intelligence`	`prebuilt-read`	`azure-document-intelligence/prebuilt-read`	Ասինքրոն վերին հոսք (`analyze` + հարցում)՝ տե՛ս ստորև։
`vertex-deepseek-ocr`	`deepseek-ocr-maas`	`vertex-deepseek-ocr/deepseek-ocr-maas`	Սինքրոն՝ Vertex AI-ի `openapi/chat/completions` գործընկերային վերջնակետի միջոցով․ նույնականացման/URL-ի համար տե՛ս ստորև։

Բոլոր երեք մատակարարները պատասխանում են Mistral-ի կառուցվածքին համապատասխանող միևնույն մարմնով՝

{
  "pages": [{ "index": 0, "markdown": "# Extracted text..." }],
  "model": "mistral-ocr-latest",
  "usage_info": { "pages_processed": 1 }
}

Azure Document Intelligence-ի հարցումների հոսքը

Azure Document Intelligence-ի analyze API-ն ասինքրոն է․ սկզբնական հարցումը մարմնի փոխարեն վերադարձնում է Operation-Location վերնագիր, և արդյունքը պետք է պարբերաբար հարցվի։ Մշակիչը (open-sse/handlers/ocr.ts) այդ URL-ին հարցում է ուղարկում յուրաքանչյուր վայրկյանը մեկ՝ առավելագույնը 30 փորձի ընթացքում, անմիջապես ձախողվում է (չի շարունակում հարցումները) ոչ ok հարցման պատասխանի կամ "failed" կարգավիճակի դեպքում և վերադարձնում է 504, եթե փորձերի սահմանաչափը սպառվելուց հետո գործողությունը դեռ կատարվում է։ Azure-ի վերջնական պատասխանը, նախքան այն կանչողին վերադարձնելը, նորմալացվում է Mistral-ի օգտագործած նույն pages/markdown կառուցվածքին, ուստի հաճախորդի կոդը կարիք չունի մատակարարի համար հատուկ մշակում կիրառելու։

Vertex AI DeepSeek OCR-ի նույնականացումը և վերջնակետի որոշումը

vertex-deepseek-ocr-ը կրկին օգտագործում է Vertex AI-ի նույնականացման նույն մեխանիզմը, որն OmniRoute-ն արդեն աջակցում է զրույցների/պատկերների տրաֆիկի համար (open-sse/executors/vertex.ts)․ կապի API բանալին կա՛մ Service Account JSON հավատարմագիր է (որը JWT-bearer հոսքի միջոցով փոխանակվում է կարճաժամկետ OAuth հասանելիության տոկենի հետ), կա՛մ արդեն ստեղծված OAuth հասանելիության տոկեն, որն օգտագործվում է առանց փոփոխության։ Վերին հոսքի վերջնակետի URL-ը Vertex-ի ընդհանուր openapi/chat/completions գործընկերային վերջնակետն է, որը կառուցվում է կապի նախագծից և տարածաշրջանից․ բացահայտ նշված providerSpecificData.project/providerSpecificData.region-ը միշտ առաջնահերթ է, հակառակ դեպքում նախագիծը ստացվում է Service Account JSON-ի project_id-ից, իսկ տարածաշրջանի լռելյայն արժեքը us-central1 է։ Երկու որոշումներն էլ կատարվում են open-sse/handlers/ocr.ts-ում (resolveVertexOcrAccessToken, resolveVertexOcrBaseUrl) և օգտագործվում են src/app/api/v1/ocr/route.ts-ի կողմից՝ նախքան հարցումը handleOcr-ին փոխանցելը։

Մոդելների ցանկ

GET /v1/models
Authorization: Bearer your-api-key

→ Վերադարձնում է զրույցի, embedding-ի և պատկերների բոլոր մոդելները + համակցությունները՝ OpenAI ձևաչափով

Մոդելի id-ի նախածանցներ (`?prefix=`)

Մոդելների մեծ մասը ներկայացվում է մատակարարի նախածանցով։ Ձեր ստացած նախածանցը վերահսկվում է MODELS_CATALOG_PREFIX_MODE գործառույթի դրոշակով և կարող է վերագրվել յուրաքանչյուր հարցման համար՝ հարցման պարամետրի միջոցով․ սա օգտակար է այն հաճախորդի համար, որը ցանկանում է մաքուր ցանկ՝ առանց բոլորի համար սերվերի ընդհանուր կարգավորումը փոխելու․

GET /v1/models?prefix=alias        # յուրաքանչյուր մոդելի համար մեկ id՝ կարճ alias նախածանցով
GET /v1/models?prefix=dual         # երկու ձևերն էլ (սերվերի լռելյայն տարբերակը)
GET /v1/models?prefix=canonical    # միայն մատակարարի ամբողջական id-ի նախածանցը

Ռեժիմ	Արտածում է	Նշումներ
`dual`	`cc/claude-sonnet-4-6` և `claude/claude-sonnet-4-6`	Լռելյայն։ Երկու id-ներն էլ ուղղորդվում են նույն մոդելին․ սա պահպանվել է, որպեսզի դրանցից որևէ մեկը հաստատագրված պարունակող հաճախորդների կարգավորումները շարունակեն աշխատել։ Կատալոգը մոտավորապես կրկնապատկվում է։
`alias`	`cc/claude-sonnet-4-6`	Յուրաքանչյուր մոդելի համար մեկ գրառում։ Առանձին alias չունեցող մատակարարները նույնպես արտածում են իրենց գրառումը, ուստի ոչինչ չի կորչում։
`canonical`	`claude/claude-sonnet-4-6`	Յուրաքանչյուր մոդելի համար մեկ գրառում՝ մատակարարի ամբողջական id-ի նախածանցով։ Առանձին alias չունեցող մատակարարները (օրինակ՝ `antigravity/…`, `agy/…`) այստեղ նույնպես արտածում են իրենց միակ id-ն, ուստի ոչինչ չի կորչում։

dual ռեժիմով հայելին հնարավոր է ճանաչել նաև առանց հարցման պարամետրի․ այն պարունակում է առաջնային id-ն մատնանշող parent դաշտ։

Մոդելի ընտրիչ ցուցադրող հաճախորդները պետք է հարցում կատարեն ?prefix=alias-ով․ հենց այսպես է վարվում OmniCopilot VS Code ընդլայնումը։

Առանց մտածողության մոդելային տարբերակներ

Մտածողության հնարավորություն ունեցող Claude մոդելների համար /v1/models-ը նաև ներկայացնում է առանց մտածողության տարբերակ, որի id-ն սկսվում է claude-3-omniroute-no-thinking/ նախածանցով․

claude-3-omniroute-no-thinking/<provider>/<model>

Այս id-ն ընտրելու դեպքում (օրինակ՝ Claude Code-ի այն կարգավորման մեջ, որը միշտ կցում է thinking բլոկ) այն վերածվում է իրական <provider>/<model>-ի՝ ճնշված reasoning-ով․ /v1/messages ուղու վրա՝ thinking:{type:"disabled"}, իսկ /v1/chat/completions ուղու վրա՝ հեռացված reasoning/reasoning_effort դաշտեր։ Այս տարբերակը ցուցակվում է միայն Claude ընտանիքի այն մոդելների համար, որոնք աջակցում են thinking-ին և ընդունում են disabled-ը (այսինքն՝ օրինակ միայն adaptive ռեժիմով աշխատող և disabled-ը մերժող մոդելները բացառվում են)։ Օպերատորները կարող են յուրաքանչյուր մոդելի համար հարկադրաբար միացնել կամ անջատել այս տարբերակը՝ ModelSpec.noThinkingAlias-ի միջոցով։

Մատակարարի հավելման մանիֆեստ

GET /api/v1/provider-plugin-manifest

Վերադարձնում է Bifrost-ի, CLIProxyAPI-ի և ապագա sidecar երթուղիչների կողմից օգտագործվող՝ JSON-ի համար անվտանգ մատակարարի հավելման մանիֆեստը։ Պատասխանը ստեղծվում է TypeScript-ի մատակարարների ռեեստրից և միտումնավոր չի ներառում OAuth հաճախորդի գաղտնիքները, կատարման միջավայրի որոշարկումը, կատարող ֆունկցիաները, հարցման վերնագրերը և հաշիվների տվյալները։

Օգտագործեք այս վերջնակետը, երբ sidecar-ն աշխատում է հիմնական գործընթացից դուրս և չի կարող ուղղակիորեն ներմուծել open-sse/config/providerPluginManifestRegistry.ts։

Համատեղելիության վերջնակետեր (Endpoints)

Մեթոդ	Ուղի	Ձևաչափ
POST	`/v1/chat/completions`	OpenAI
POST	`/v1/messages`	Anthropic
POST	`/v1/responses`	OpenAI Responses
POST	`/v1/embeddings`	OpenAI
POST	`/v1/images/generations`	OpenAI Images
POST	`/v1/images/edits`	OpenAI Images (edit/inpaint)
POST	`/v1/videos/generations`	OpenAI-style տեսանյութի ստեղծում
POST	`/v1/music/generations`	OpenAI-style երաժշտության ստեղծում
POST	`/v1/audio/transcriptions`	OpenAI Audio (STT)
POST	`/v1/audio/speech`	OpenAI TTS (վերադարձնում է աուդիո)
POST	`/v1/rerank`	Cohere/Voyage-style rerank
POST	`/v1/classify`	Jina classify (`api.jina.ai`)
POST	`/v1/segment`	Jina segmenter (`segment.jina.ai`)
POST	`/v1/moderations`	OpenAI Moderations
GET	`/v1/models`	OpenAI
POST	`/v1/messages/count_tokens`	Anthropic
GET	`/v1beta/models`	Gemini
POST	`/v1beta/models/{...path}`	Gemini generateContent
POST	`/v1/api/chat`	Ollama
GET	`/api/v1/vscode/{token}/`	OpenAI catalog alias
GET	`/api/v1/vscode/{token}/models`	OpenAI models alias
POST	`/api/v1/vscode/{token}/chat/completions`	OpenAI tokenized alias
POST	`/api/v1/vscode/{token}/responses`	OpenAI Responses tokenized alias
POST	`/api/v1/vscode/{token}/api/chat`	Ollama tokenized alias
GET	`/api/v1/vscode/{token}/api/tags`	Ollama tags tokenized alias

Բոլոր POST երթուղիները հետևում են նույն կառուցվածքին՝ Bearer your-api-key + Zod-ով վավերացված JSON մարմին (v1RerankSchema, v1ModerationSchema, v1AudioSpeechSchema և այլն, տես src/shared/validation/schemas.ts): Սխեմայի անհամապատասխանության դեպքում վերադարձվում է 4xx սխալ:

Այն հաճախորդների համար, որոնք չեն կարող կցել Authorization: Bearer ... վերնագիրը, OmniRoute-ը ընդունում է API բանալիները նաև URL-ի միջոցով՝ կամ query-string համատեղելիությամբ (?token=..., ?apiKey=..., ?api_key=..., ?key=...), կամ ստորև նշված հատուկ /api/v1/vscode/{token}/... վերջնակետերի միջոցով:

# Rerank (ամպային ռեգիստրի մատակարար կամ OpenAI-համատեղելի մատակարարի հանգույց որպես "<prefix>/<model>")
POST /v1/rerank      { "model": "jina-ai/jina-reranker-v3.5", "query": "...", "documents": ["..."] }

# Jina classify (Foundation API հավատարմագրեր)
POST /v1/classify    { "model": "jina-embeddings-v5-text-small", "input": ["..."], "labels": ["a", "b"] }

# Jina segmenter
POST /v1/segment     { "content": "...", "return_chunks": true }

# Jina search (s.jina.ai; մատակարարի ալիասներ՝ jina-search, jina-ai, jina)
POST /v1/search      { "query": "...", "provider": "jina-search" }

# Moderations
POST /v1/moderations { "model": "omni-moderation-latest", "input": "..." }

# TTS — վերադարձնում է audio/mpeg (կամ հայցվող ձևաչափի) մարմին
POST /v1/audio/speech { "model": "openai/tts-1", "input": "Hello", "voice": "alloy" }

# Պատկերի խմբագրում (multipart)
POST /v1/images/edits  -F image=@input.png -F prompt="..." -F mask=@mask.png

# Տեսանյութի / երաժշտության ստեղծում (մատակարարի նախդիրով մոդելի id)
POST /v1/videos/generations { "model": "runway/gen-3", "prompt": "..." }
POST /v1/music/generations  { "model": "suno/v3.5",   "prompt": "..." }

Rerank մատակարարի հանգույցներ: POST /v1/rerank-ը նաև ուղղորդում է դեպի OpenAI-համատեղելի մատակարարի հանգույցներ (oMLX, vLLM, Infinity, TEI դարպասի հետևում և այլն), որոնք հասցեավորվում են որպես <node-prefix>/<model>: Loopback հանգույցները (localhost, 127.0.0.1, 172.16.0.0/12) միշտ հասանելի են: Ցանկացած այլ հոսթի վրա գտնվող հանգույցները՝ LAN սարք կամ Tailscale հանգույց, հասանելի են միայն այն դեպքում, երբ օպերատորը միացնում է RERANK_REMOTE_PROVIDER_NODES ֆունկցիոնալ դրոշը և հանգույցի հիմնական URL-ն անցնում է մատակարարի արտաքին URL քաղաքականությունը (OMNIROUTE_ALLOW_LOCAL_PROVIDER_URLS / OMNIROUTE_ALLOW_PRIVATE_PROVIDER_URLS): Cloud-metadata հոսթերին երբեք հարցումներ չեն ուղղվում: Հիշողության շարժիչի (memory engine) rerank քայլը կանչում է այս երթուղին loopback-ի միջոցով, ուստի նույն կանոնը կարգավորում է նաև rerankProviderModel-ը Memory կարգավորումներում:

Տեղական սերվերի ձևաչափեր: հանգույցը կանչվում է <base>/v1/rerank հասցեով, իսկ 404-ի դեպքում՝ <base>/rerank (Infinity, TEI): Ելքային մարմինը կրում է և՛ Cohere/OpenAI ուղղագրությունը (documents, return_documents), և՛ TEI ուղղագրությունը (texts, return_text), իսկ պատասխանը նորմալացվում է ըստ Cohere-ի ձևաչափի. TEI-ի պարզ [{index, score, text}]-ը, պարզ դարպասների {results: [{index, score}]}-ը և Voyage-ոճի {data: [...]}-ը բոլորը վերադառնում են հաճախորդին որպես {results: [{index, relevance_score, document?}]}, տեսակավորված ըստ միավորի և սահմանափակված top_n-ով:

Մատակարարի հանգույցների հայտնաբերում: OpenAI-համատեղելի մատակարարի հանգույցի մոդելները հայտնվում են GET /v1/models ցանկում՝ հանգույցի նախդիրի տակ: Այն տողերը, որոնք չունեն վերջնակետի մետատվյալներ (բնորոշ է տեղական /v1/models ցուցակներին), ժառանգում են հանգույցի apiType-ը, ուստի embeddings հանգույցի մոդելները ստանում են type: "embedding", իսկ rerank հանգույցի մոդելները՝ type: "rerank"՝ լռելյայն chat-ի փոխարեն: Սինքրոնացված կամ ձեռքով ավելացված տողի վրա հստակ նշված supportedEndpoints-ը դեռևս ունի առաջնահերթություն:

Մատակարարի հատուկ երթուղիներ

POST /v1/providers/{provider}/chat/completions
POST /v1/providers/{provider}/embeddings
POST /v1/providers/{provider}/images/generations

provider նախածանցն ավտոմատ կերպով ավելացվում է, եթե բացակայում է։ Անհամապատասխան մոդելները վերադարձնում են 400։

Ֆայլերի API

OpenAI-ի հետ համատեղելի ֆայլերի վերջնակետ՝ փաթեթային մուտքագրման/ելքագրման և ըստ նշանակության ֆայլերի վերբեռնման համար։

Մեթոդ	Ուղի	Նկարագրություն
POST	`/v1/files`	Վերբեռնել ֆայլ (multipart՝ `file`, `purpose`, `expires_after[anchor]`, `expires_after[seconds]`) — առավելագույնը 512 MiB
GET	`/v1/files`	Ցուցակել նույնականացված API բանալուն պատկանող ֆայլերը
GET	`/v1/files/[id]`	Ստանալ ֆայլի մետատվյալները
DELETE	`/v1/files/[id]`	Ջնջել ֆայլը
GET	`/v1/files/[id]/content`	Հոսքային եղանակով վերադարձնել ֆայլի չմշակված բովանդակությունը

Նույնականացում․ Bearer API բանալի — ֆայլերը սահմանափակված են ըստ API բանալու՝ getApiKeyRequestScope-ի միջոցով։ Բանալին տեսնում, ներբեռնում և ջնջում է միայն իրեն պատկանող ֆայլերը․ առանց բանալու կառավարման վահանակի աշխատաշրջանը կարդում է ամբողջ օրինակը․ սեփականատեր չունեցող ֆայլը (անանուն կամ կառավարման վահանակի աշխատաշրջանի միջոցով վերբեռնված) մերժվում է յուրաքանչյուր ոչ աշխատաշրջանային կանչողի համար։ GET /v1/files-ը անանուն կանչողին, ինչպես նաև տրամադրված, սակայն չգտնված բանալիով կանչողին վերադարձնում է 401, նույնիսկ երբ REQUIRE_API_KEY=false՝ բոլոր վարձակալների ֆայլերը ցուցակելու փոխարեն (GHSA-m3hp-hq9g-fpmv, GHSA-2jm2-mpx8-6523)։

Batches API

OpenAI-ի հետ համատեղելի փաթեթային մշակում։

Մեթոդ	Ուղի	Նկարագրություն
POST	`/v1/batches`	Ստեղծել փաթեթ — հարցման մարմինը վավերացվում է `v1BatchCreateSchema`-ով (`input_file_id`, `endpoint`, `completion_window`)
GET	`/v1/batches`	Ցուցակել փաթեթները
GET	`/v1/batches/[id]`	Ստանալ փաթեթի կարգավիճակը + `request_counts`
DELETE	`/v1/batches/[id]`	Ջնջել ավարտված/ձախողված փաթեթը
POST	`/v1/batches/[id]/cancel`	Չեղարկել ընթացքի մեջ գտնվող փաթեթը

Նույնականացում․ Bearer API բանալի։ Փաթեթների հասանելիության շրջանակը սահմանվում է ըստ API բանալու՝ նույն եռակողմ կանոնով, ինչ ֆայլերի դեպքում․ հասանելի է միայն սեփական բանալիով, կառավարման վահանակի աշխատաշրջանին՝ ամբողջ օրինակի մասշտաբով, իսկ սեփականատեր չունեցող գրառումների հասանելիությունը մերժվում է աշխատաշրջանից դուրս բոլոր դիմողներին (ստացում, ջնջում, չեղարկում և ստեղծելիս input_file_id-ի ստուգում)։ GET /v1/batches-ը անանուն դիմողին վերադարձնում է 401, նույնիսկ երբ REQUIRE_API_KEY=false։

Որոնման API

Վեբ/որոնման մատակարարների աբստրակցիա (Tavily, Brave, Exa, Serper և այլն)։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/v1/search`	Ցուցադրել կազմաձևված որոնման մատակարարները և նրանց հնարավորությունները
POST	`/v1/search`	Կատարել որոնման հարցում — հարցման մարմինը վավերացվում է `v1SearchSchema`-ով, աջակցում է քեշավորում/միավորում
GET	`/v1/search/analytics`	Յուրաքանչյուր մատակարարի արդյունքների/ուշացման/քեշի վիճակագրություն

Նույնականացում․ Bearer API բանալի (extractApiKey + isValidApiKey)։ Որոնման քաղաքականությունը կիրառվում է enforceApiKeyPolicy-ի միջոցով։

Web Fetch API

Կորզեք բովանդակությունը URL-ից՝ կազմաձևված web-fetch մատակարարի միջոցով (Firecrawl, Jina Reader, Tavily Extract, TinyFish Fetch, Nimble Extract)։

Մեթոդ	Ուղի	Նկարագրություն
POST	`/v1/web/fetch`	Ստանալ/քերել URL-ը՝ հարցման մարմինը վավերացնելով `v1WebFetchSchema`-ի միջոցով

Նույնականացում․ Bearer API բանալի (extractApiKey + isValidApiKey)։ Քաղաքականությունը կիրառվում է enforceApiKeyPolicy-ի միջոցով։

Քվոտան հաշվի առնող պահուստային անցում (#8297)․ երբ հստակ provider նշված չէ, համախումբը (firecrawl → jina-reader → tavily-search → tinyfish → nimble-search) շրջանցվում է ամրագրված առաջնահերթության կարգով (նախ լրացնելով)․ արագության սահմանափակման հասած, բայց կազմաձևված մատակարարը բաց է թողնվում՝ հարցումն անմիջապես ընդհատելու փոխարեն, իսկ վերափորձելի/քվոտային վերին հոսքի ձախողման դեպքում (HTTP 429՝ միշտ, 402/403՝ Firecrawl/Tavily/TinyFish-ի քվոտայով պայմանավորված անվճար մակարդակների համար, բայց ոչ Jina Reader-ի համար և երբեք ոչ սովորական 400 սխալ հարցման դեպքում) հարցման կատարման պահին անցում է կատարվում հաջորդ՝ դեռ չփորձված և հավատարմագրեր ունեցող մատակարարին։ Երբ համախմբի բոլոր մատակարարների հնարավորությունները սպառված են, վերջնակետը նախկին ընդհանուր 400-ի փոխարեն վերադարձնում է մեկ 429 (Retry-After վերնագրով)։ Երբ հստակ provider է պահանջվում, լուռ պահուստային անցում չկա․ արագության սահմանափակման հասած կամ ձախողված հստակ մատակարարի սեփական սխալն է վերադարձվում (429, եթե արագությունը սահմանափակված է, հակառակ դեպքում՝ վերին հոսքի կարգավիճակը)։

WebSocket հոսքային փոխանցում

GET /v1/ws?handshake=1

Վավերացնում է WebSocket-ի արդիականացման ձեռքսեղմումը և վերադարձնում հաղորդալարային արձանագրության հաղորդագրությունների օրինակները (request, cancel)։ Իրական WS ֆրեյմները մշակվում են փաթեթում ներառված WS սերվերի կողմից՝ Next.js-ի երթուղիների աղյուսակից դուրս։

Նույնականացում․ Bearer API բանալի՝ ձեռքսեղմման ընթացքում։

Responses API-ն WebSocket-ի միջոցով (միայն codex)

# Նույն հոսթը և պորտը, ինչ HTTP API-ի համար է (լռելյայն՝ 20128)․ արդիականացրեք կապը.
wscat -c "ws://localhost:20128/v1/responses?api_key=<OMNIROUTE_API_KEY>"
# (կամ՝ -H "Authorization: Bearer <OMNIROUTE_API_KEY>")

# Առաջին ֆրեյմը ՊԵՏՔ Է լինի response.create.
{ "type": "response.create", "model": "gpt-5.5", "input": [ { "role": "user", "content": "hi" } ] }

Responses-API-over-WebSocket պրոքսին միացված է բացառապես codex-ին (ChatGPT հետնամաս)։ Այն լսում է API-ի/կառավարման վահանակի նույն պորտում՝ /v1/responses, /responses և /api/v1/responses ուղիներով։ Առաջին response.create ֆրեյմի ժամանակ այն նույնականացնում և նախապատրաստում է ներքին codex-responses-ws կամրջի միջոցով, ընտրում է codex OAuth կապ և թունելավորում դեպի wss://chatgpt.com/backend-api/codex/responses wreq-js փոխադրամիջոցի միջոցով։ Ոչ codex մոդելները մերժվում են (codex_ws_provider_required)։ Քվոտայի համօգտագործմամբ երթուղավորման համար օգտագործեք model: "qtSd/<group>/codex/<model>"։ Իրականացված է app/server-ws.mjs + scripts/dev/responses-ws-proxy.mjs + src/app/api/internal/codex-responses-ws/route.ts ֆայլերում։

Նույնականացում․ Bearer API բանալի՝ ձեռքսեղմման ընթացքում։ Փաթեթում ներառված HTTP սերվերը (server-ws.mjs) պետք է լինի ակտիվ մուտքի կետը (այն լռելյայն այդպիսին է, երբ app/server-ws.mjs-ը գոյություն ունի)։

Մոդելի id․ օգտագործեք ChatGPT-ի պարզ id-ն (առանց `codex/` նախածանցի)

OpenAI Codex CLI-ն հաճախորդի կողմում վավերացնում է մոդելի անունը, երբ supports_websockets = true, և մերժում է մատակարարի նախածանցով id-ները, ինչպիսին է codex/gpt-5.5-ը (The 'codex/gpt-5.5' model is not supported when using Codex with a ChatGPT account)։ Ուղարկեք պարզ id-ն (օրինակ՝ gpt-5.5)։ OmniRoute-ի կամուրջը միայն codex-ի համար է, ուստի վերին հոսք թունելավորելուց առաջ այն պարզ id-ն կրկին լուծարկում է որպես codex մոդել (resolveCodexWsModelInfo), թեև պարզ gpt-5.5-ը հակառակ դեպքում HTTP-ի միջոցով կերթուղավորվեր մեկ այլ մատակարարի մոտ։

OpenAI Codex CLI-ի կազմաձևումը

Ուղղեք Codex CLI-ն դեպի OmniRoute՝ ~/.codex/config.toml-ում ավելացնելով WebSocket-ի աջակցությամբ հատուկ մատակարար (օգտագործեք առանձին CODEX_HOME, որպեսզի գոյություն ունեցող կազմաձևումը չփոփոխեք)։

model = "gpt-5.5"                 # պարզ id — ՈՉ ԹԵ "codex/gpt-5.5"
model_provider = "omniroute"

[model_providers.omniroute]
name = "OmniRoute (WS)"
base_url = "http://localhost:20128/v1"   # առանց վերջավոր շեղագծի․ WS URL-ը ստացվում է սրանից (արտադրական միջավայրում օգտագործեք https/wss)
wire_api = "responses"                    # միակ աջակցվող արժեքը՝ 2026 թ. փետրվարից ի վեր
supports_websockets = true                # միացնում է Responses-over-WS փոխադրամիջոցը
env_key = "OMNIROUTE_API_KEY"             # պարունակում է OmniRoute API բանալին (Bearer)

export OMNIROUTE_API_KEY=sk-...           # OmniRoute API բանալի (ցանկացած բանալի, եթե REQUIRE_API_KEY=false)
codex exec "Responda apenas: PONG"

CLI-ն base_url + /responses-ը արդիականացնում է WebSocket-ի, իսկ OmniRoute-ն այն թունելավորում է դեպի ընտրված codex OAuth կապը։ Ամբողջ շղթայով վավերացվել է տեղային սերվերի նկատմամբ․ ChatGPT-ն վերադարձնում է codex.rate_limits + response.created և հոսքային եղանակով փոխանցում է ավարտված պատասխանը։

Քվոտաների և խնդիրների հաղորդում

Մեթոդ	Ուղի	Նկարագրություն
GET	`/v1/quotas/check`	Նախապես վավերացնել `provider` + `accountId`-ի քվոտան՝ գրանցված բանալի տրամադրելուց առաջ
POST	`/v1/issues/report`	GitHub-ին հաղորդել քվոտայի/բանալու տրամադրման ձախողման մասին (պահանջում է `GITHUB_ISSUES_REPO` + թոքեն)

Նույնականացում՝ Bearer API բանալի (isAuthenticated)։

Ինքնասպասարկման օգտագործում (`/api/usage/om-usage`)

Ցանկացած API բանալի կարող է կարդալ իր սեփական օգտագործման և քվոտաների տվյալները՝ առանց կառավարման նույնականացման։ Սա այն վերջնակետն է, որն օգտագործում է հաճախորդը (CLI, OmniCopilot վահանակ)՝ բանալու տիրոջը նրա ծախսերը ցուցադրելու համար։

# Տեքստային ձևաչափ (պատմական պայմանագիրը՝ պարզ տեքստ տերմինալի համար)
curl -H "Authorization: Bearer <your-api-key>" \
  http://localhost:20128/api/usage/om-usage

# Կառուցվածքային ձևաչափ՝ այն, որն օգտագործում է UI-ը
curl -H "Authorization: Bearer <your-api-key>" \
  "http://localhost:20128/api/usage/om-usage?format=json"

Բանալու համար allowUsageCommand-ը պետք է միացված լինի (լռելյայն անջատված է. կառավարման վահանակի API բանալիների կառավարիչն այն փոխարկում է յուրաքանչյուր բանալու համար)։ Առանց դրա վերջնակետը պատասխանում է 403։

?format=json-ը վերադարձնում է տարբերակելի կառուցվածք, որպեսզի կանչողը երբեք տվյալների դաշտ չկարդա մերժման պատասխանից։ Հաջողության դեպքում՝

{
  "allowed": true,
  // առկա է միայն այն դեպքում, երբ բանալու համար միացված են անհատական օգտագործման սահմանաչափերը (օրական/շաբաթական USD).
  "personal": {
    "dailySpentUsd": 1.25,
    "dailyLimitUsd": 5,
    "dailyResetAtIso": "…",
    "weeklySpentUsd": 8,
    "weeklyLimitUsd": 20,
    "weeklyResetAtIso": "…" /* … */,
  },
  // ընտրված մատակարարի քվոտայի ակնթարթային պատկերը կամ null, երբ դեռ ոչինչ քեշավորված չէ.
  "provider": {
    "connectionId": "…",
    "provider": "claude",
    "plan": "…",
    "quotas": {/* … */},
  },
  // յուրաքանչյուր կապի ակնթարթային պատկերը, որպեսզի UI-ը կարողանա մի քանի մատակարար կողք կողքի ցուցադրել.
  "providers": [
    { "connectionId": "…", "provider": "claude" /* … */ },
    { "provider": "codex" /* … */ },
  ],
}

Մերժման դեպքում (401՝ սխալ բանալի / 403՝ թույլատրված չէ) նույն երթուղին վերադարձնում է { "allowed": false, "error": { "message": "…" } }։ Առկա, բայց դատարկ personal/provider-ը (բանալին թույլատրված է, բայց դեռ տվյալներ չեն ստացվել) տարբերվում է մերժումից, և դրանք տարբերակում է միայն JSON ձևաչափը։

Նույնականացում՝ կանչողի սեփական Bearer API բանալի՝ վավերացված isValidApiKey-ով։ Սա կառավարման մակերեսը չէ (/api/keys/…), որը շարունակում է պաշտպանված մնալ requireManagementAuth-ով։

Իմաստաբանական քեշ

# Ստանալ քեշի վիճակագրությունը
GET /api/cache/stats

# Մաքրել բոլոր քեշերը
DELETE /api/cache/stats

Պատասխանի օրինակ՝

{
  "semanticCache": {
    "memorySize": 42,
    "memoryMaxSize": 500,
    "dbSize": 128,
    "hitRate": 0.65
  },
  "idempotency": {
    "activeKeys": 3,
    "windowMs": 5000
  }
}

Ազդեցությունը ուշացման վրա

Իմաստաբանական քեշում համընկնումը պատասխանը տրամադրում է քեշից՝ առանց վերին հոսքին կանչ կատարելու, ուստի հաղորդվող X-OmniRoute-Response-Latency-ն գրեթե զրոյական է (անկախ վերին հոսքի սկզբնական ուշացումից)։ Ուշացման նկատմամբ զգայուն հաճախորդները (արտադրողականության չափում, p50/p99 մոնիթորինգ) պետք է ստուգեն պատասխանի X-OmniRoute-Cache-Latency վերնագիրը՝

Արժեք	Նշանակություն
`synthetic`	Պատասխանը տրամադրվել է քեշից. ուշացումը վերին հոսքի իրական ժամանակը չէ
(բացակայում է)	Պատասխանը ստացվել է վերին հոսքին կատարված իրական կանչից

Քեշի շրջանցում՝ ըստ բանալու

API բանալիները կարող են հրաժարվել իմաստաբանական քեշից կարդալուց՝ cacheDefaultMode-ի միջոցով՝

Արժեք	Վարքագիծ
`legacy`	Քեշի սովորական վարքագիծ (լռելյայն)
`bypass`	Ամբողջությամբ բաց թողնել քեշի որոնումը. միշտ դիմել վերին հոսքին

Սահմանեք բանալին ստեղծելիս (POST /api/keys) կամ թարմացնելիս (PATCH /api/keys/[id])՝

{ "cacheDefaultMode": "bypass" }

Շրջանցում՝ ըստ հարցման

Ցանկացած հարցում կարող է շրջանցել քեշը՝ անկախ բանալու կարգավորումներից՝

X-OmniRoute-No-Cache: true

Վահանակ և կառավարում

Կառավարման երթուղիները (/api/*, բացառությամբ հանրային նույնականացման/մուտքի) չեն թույլատրվում սովորական inference API բանալիներով։ Հավատարմագրերի տեսակները, հասանելիության շրջանակները և curl-ի օրինակները՝ Կառավարման նույնականացում։

Նույնականացում

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/auth/login`	POST	Մուտք
`/api/auth/logout`	POST	Ելք
`/api/settings/require-login`	GET/PUT	Միացնել կամ անջատել պարտադիր մուտքը

Մատակարարների կառավարում

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/providers`	GET/POST	Ցուցակագրել / ստեղծել մատակարարներ
`/api/providers/[id]`	GET/PUT/DELETE	Կառավարել մատակարարին
`/api/providers/[id]/test`	POST	Փորձարկել մատակարարի կապը
`/api/providers/[id]/models`	GET	Ցուցակագրել մատակարարի մոդելները
`/api/providers/validate`	POST	Վավերացնել մատակարարի կազմաձևումը
`/api/providers/bulk`	POST	Զանգվածաբար ավելացնել API բանալիներ ՄԵԿ մատակարարի համար
`/api/providers/import`	POST	Ներմուծել մատակարարների տարասեռ ՑՈՒՑԱԿ վերլուծված CSV/JSON ֆայլից (#6836)․ մասնակի ձախողման արդյունքներ՝ ըստ յուրաքանչյուր տողի
`/api/provider-nodes*`	Տարբեր	Մատակարարի հանգույցների կառավարում
`/api/provider-models`	GET/POST/PATCH/DELETE	Հատուկ մոդելներ (ավելացնել, թարմացնել, թաքցնել/ցուցադրել, ջնջել)

OAuth հոսքեր

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/oauth/[provider]/[action]`	Տարբեր	Մատակարարին հատուկ OAuth

Երթուղավորում և կազմաձևում

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/models/alias`	GET/POST	Մոդելների այլանուններ
`/api/models/catalog`	GET	Բոլոր մոդելներն՝ ըստ մատակարարի և տեսակի
`/api/combos*`	Տարբեր	Համակցությունների կառավարում
`/api/keys*`	Տարբեր	API բանալիների կառավարում
`/api/pricing`	GET	Մոդելների գնագոյացում

Օգտագործում և վերլուծություն

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/usage/history`	GET	Օգտագործման պատմություն
`/api/usage/logs`	GET	Օգտագործման մատյաններ
`/api/usage/request-logs`	GET	Հարցման մակարդակի մատյաններ
`/api/usage/[connectionId]`	GET	Յուրաքանչյուր կապի օգտագործում
`/api/usage/token-limits`	GET/POST/DELETE	Յուրաքանչյուր API բանալու թոքենների սահմանաչափի բյուջեներ
`/api/usage/model-latency-stats`	GET	Յուրաքանչյուր մատակարարի/մոդելի սահող ուշացման ագրեգացված տվյալներ (միջին/p50/p95/p99, հաջողության գործակից), զտիչներ՝ `windowHours`/`minSamples`/`maxRows`/`provider`/`model` (#6873)
`/api/usage/cache-health`	GET	`call_logs`-ի հիման վրա հուշումների քեշի վիճակի ամփոփում՝ գրելու/կարդալու հարաբերակցություն, գրառման չափերի p50/p90/p99 բաշխում, մեծածավալ գրառումների կենտրոնացում, ըստ մոդելների բաժանում և `healthy`/`degraded`/`thrash`/`no-data` վճիռ, հարցման պարամետրեր՝ `range` (`1h`\|`24h`\|`7d`\|`30d`, լռելյայն՝ `24h`) և ընտրովի `model` (#8827)

Կարգավորումներ

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/settings`	GET/PUT/PATCH	Ընդհանուր կարգավորումներ
`/api/settings/proxy`	GET/PUT	Ցանցային պրոքսիի կազմաձևում
`/api/settings/proxy/test`	POST	Պրոքսի կապի փորձարկում
`/api/settings/ip-filter`	GET/PUT	IP թույլատրման/արգելափակման ցանկ
`/api/settings/thinking-budget`	GET/PUT	Մտածողության/դատողության հարցման վերագրման ռեժիմ (անփոփոխ փոխանցում / ինքնաշխատ հեռացում / անհատական / հարմարվողական)։ Սեղմումից անկախ է։ Տե՛ս THINKING_BUDGET.md։
`/api/settings/system-prompt`	GET/PUT	Համընդհանուր համակարգային հուշում
`/api/settings/compression`	GET/PUT	Համընդհանուր սեղմման կազմաձևում
`/api/settings/purge-request-history`	POST	Մաքրել հարցումների մատյանի տողերը և կանչերի մատյանի տեղային արտեֆակտները

Համատեքստ և սեղմում

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/compression/preview`	POST	off/lite/standard/aggressive/ultra/RTK/stacked սեղմման նախադիտում
`/api/compression/language-packs`	GET	Հասանելի Caveman լեզվային փաթեթների ցանկ
`/api/compression/rules`	GET	Caveman կանոնների մետատվյալների ցանկ
`/api/context/caveman/config`	GET/PUT	Caveman-ին հատուկ կարգավորումների այլանուն
`/api/context/rtk/config`	GET/PUT	RTK-ին հատուկ կարգավորումներ՝ ներառյալ անհատական զտիչները և չմշակված ելքի պահպանումը
`/api/context/rtk/filters`	GET	RTK զտիչների կատալոգ և անհատական զտիչների ախտորոշում
`/api/context/rtk/test`	POST	RTK նախադիտման/թեստի գործարկում տեքստային տվյալների նկատմամբ
`/api/context/rtk/raw-output/[id]`	GET	Պահպանված, խմբագրված չմշակված ելքի ընթերցում՝ ըստ ցուցիչի id-ի
`/api/context/combos`	GET/POST	Սեղմման համակցությունների ցանկ/ստեղծում
`/api/context/combos/[id]`	GET/PUT/DELETE	Սեղմման համակցության մանրամասներ/թարմացում/ջնջում
`/api/context/combos/[id]/assignments`	GET/PUT	Սեղմման համակցությունների վերագրում երթուղավորման համակցություններին
`/api/context/analytics`	GET	Սեղմման վերլուծության այլանուն

Մոնիթորինգ

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/sessions`	GET	Ակտիվ աշխատաշրջանների հետևում
`/api/rate-limits`	GET	Յուրաքանչյուր հաշվի հարցումների հաճախականության սահմանաչափեր
`/api/monitoring/health`	GET	Առողջական վիճակի ստուգում + մատակարարների ամփոփում (`catalogCount`, `configuredCount`, `activeCount`, `monitoredCount`)։ Կառավարման տեսքը ներառում է `credentialHealth`-ը՝ զննման քեշի սկալյարներ, `failedConnections`, երբ `failed>0`, և `staleDbNonOkCount` (SQLite-ի կայուն `test_status`, ոչ թե չափիչը)։ Տե՛ս MONITORING_GUIDE.md։
`/api/cache/stats`	GET/DELETE	Քեշի վիճակագրություն / մաքրում
`/api/modality-bridge/stats`	GET	Հիշողության մեջ պահվող `attempts`, հաջողություններ/`bridged`, ձախողումներ, քեշի համապատասխանություններ, `totalLatencyMs`, `latencySamples`, նմուշների քանակով բաժանված `averageLatencyMs` և վերջին օգտագործման ժամանակը (վերակայվում է վերագործարկման ժամանակ, կառավարման նույնականացում)
`/api/modality-bridge/video/runtime`	GET	Խիստ վստահելի loopback-ի ստուգում՝ կառավարման նույնականացումից/զննումից առաջ․ մաքրված FFmpeg/ffprobe հասանելիություն և տարբերակներ (չպահել)
`/api/modality-bridge/video/extract`	POST	Ներքին, նույնականացված, վստահելի loopback բայթերի միջնորդ․ 50 MiB մուտք, սահմանափակ հերթ/32 MiB ելք, `503`՝ հզորության սահմանափակում, `499`՝ կապի անջատում, `504`՝ վերջնաժամկետ․ հանրային վերբեռնման API չէ

Պահուստավորում և արտահանում/ներմուծում

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/db-backups`	GET	Թվարկել հասանելի պահուստային պատճենները
`/api/db-backups`	PUT	Ստեղծել ձեռքով պահուստային պատճեն
`/api/db-backups`	POST	Վերականգնել որոշակի պահուստային պատճենից
`/api/db-backups/export`	GET	Ներբեռնել տվյալների բազան որպես .sqlite ֆայլ
`/api/db-backups/import`	POST	Վերբեռնել .sqlite ֆայլ՝ տվյալների բազան փոխարինելու համար
`/api/db-backups/exportAll`	GET	Ներբեռնել ամբողջական պահուստային պատճենը որպես .tar.gz արխիվ

Ամպային համաժամացում

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/sync/cloud`	Տարբեր	Ամպային համաժամացման գործողություններ
`/api/sync/initialize`	POST	Նախաստեղծել համաժամացումը
`/api/cloud/*`	Տարբեր	Ամպի կառավարում

Թունելներ

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/tunnels/cloudflared`	GET	Կարդալ Cloudflare Quick Tunnel-ի տեղադրման/աշխատաժամանակի վիճակը կառավարման վահանակի համար
`/api/tunnels/cloudflared`	POST	Միացնել կամ անջատել Cloudflare Quick Tunnel-ը (`action=enable/disable`)
`/api/tunnels/ngrok`	GET	Կարդալ ngrok Tunnel-ի աշխատաժամանակի վիճակը կառավարման վահանակի համար
`/api/tunnels/ngrok`	POST	Միացնել կամ անջատել ngrok Tunnel-ը (`action=enable/disable`)

CLI գործիքներ

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/cli-tools/claude-settings`	GET	Claude CLI-ի վիճակ
`/api/cli-tools/codex-settings`	GET	Codex CLI-ի վիճակ
`/api/cli-tools/droid-settings`	GET	Droid CLI-ի վիճակ
`/api/cli-tools/openclaw-settings`	GET	OpenClaw CLI-ի վիճակ
`/api/cli-tools/runtime/[toolId]`	GET	Ընդհանուր CLI աշխատաժամանակ

CLI-ի պատասխանները ներառում են՝ installed, runnable, command, commandPath, runtimeMode, reason։

ACP գործակալներ

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/acp/agents`	GET	Թվարկել բոլոր հայտնաբերված գործակալները (ներկառուցված + անհատական)՝ վիճակով
`/api/acp/agents`	POST	Ավելացնել անհատական գործակալ կամ թարմացնել հայտնաբերման քեշը
`/api/acp/agents`	DELETE	Հեռացնել անհատական գործակալը՝ ըստ `id` հարցման պարամետրի

GET-ի պատասխանը ներառում է agents[] (id, name, binary, version, installed, protocol, isCustom) և summary (total, installed, notFound, builtIn, custom)։

Կայունություն և հարցումների հաճախականության սահմանաչափեր

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/resilience`	GET/PATCH	Ստանալ/թարմացնել հարցումների հերթը, կապի դադարը, մատակարարի անջատիչը և սպասման կարգավորումները
`/api/resilience/reset`	POST	Վերակայել մատակարարների շղթայական անջատիչները
`/api/resilience/model-cooldowns`	GET	Թվարկել ակտիվ՝ ըստ (մատակարար, կապ, մոդել) արգելափակումները՝ դասավորված ըստ մնացած ժամանակի
`/api/resilience/model-cooldowns`	DELETE	Մաքրել մոդելի արգելափակումը՝ մարմնում `{provider, model}` կամ `{all: true}`՝ ամեն ինչ ջնջելու համար
`/api/rate-limits`	GET	Հարցումների հաճախականության սահմանաչափի վիճակ՝ ըստ հաշվի
`/api/rate-limit`	GET	Հարցումների հաճախականության սահմանաչափի համընդհանուր կազմաձևում

Բոլոր չորս /api/resilience/* երթուղիները պահանջում են կառավարման նույնականացում (requireManagementAuth)։ Մատակարարի անջատիչի, կապի դադարի և մոդելի արգելափակման ամբողջական տարբերակման համար տե՛ս Կայունություն (ընդլայնված) բաժինը։

Գնահատումներ

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/evals`	GET/POST	Թվարկել գնահատման հավաքակազմերը / գործարկել գնահատում

Քաղաքականություններ

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/policies`	GET/POST/DELETE	Կառավարել երթուղավորման քաղաքականությունները

Համապատասխանություն

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/compliance/audit-log`	GET	Համապատասխանության աուդիտի մատյան (վերջին N գրառումները)

v1beta (Gemini-ի հետ համատեղելի)

Վերջնակետ	Մեթոդ	Նկարագրություն
`/v1beta/models`	GET	Թվարկել մոդելները Gemini ձևաչափով
`/v1beta/models/{...path}`	POST	Gemini-ի `generateContent` վերջնակետը

Այս վերջնակետերը կրկնօրինակում են Gemini-ի API ձևաչափը այն հաճախորդների համար, որոնք ակնկալում են բնիկ Gemini SDK համատեղելիություն։

Ներքին / համակարգային API-ներ

Վերջնակետ	Մեթոդ	Նկարագրություն
`/api/init`	GET	Հավելվածի սկզբնավորման ստուգում (օգտագործվում է առաջին գործարկման ժամանակ)
`/api/tags`	GET	Ollama-ի հետ համատեղելի մոդելների պիտակներ (Ollama-ի հաճախորդների համար)
`/api/restart`	POST	Նախաձեռնել սերվերի սահուն վերագործարկում
`/api/shutdown`	POST	Նախաձեռնել սերվերի սահուն անջատում
`/api/system/env/repair`	POST	Վերականգնել OAuth մատակարարի միջավայրի փոփոխականները

Նշում․ Այս վերջնակետերն օգտագործվում են համակարգի կողմից ներքին նպատակներով կամ Ollama-ի հաճախորդների հետ համատեղելիության համար։ Սովորաբար վերջնական օգտատերերը դրանք չեն կանչում։

OAuth միջավայրի վերականգնում (v3.6.1+)

POST /api/system/env/repair
Content-Type: application/json

{
  "provider": "claude-code"
}

Վերականգնում է կոնկրետ մատակարարի բացակայող կամ վնասված OAuth միջավայրի փոփոխականները։ Վերադարձնում է՝

{
  "success": true,
  "repaired": ["CLAUDE_CODE_OAUTH_CLIENT_ID", "CLAUDE_CODE_OAUTH_CLIENT_SECRET"],
  "backupPath": "/home/user/.omniroute/backups/env-repair-2026-04-11.bak"
}

Ձայնագրության տառադարձում

POST /v1/audio/transcriptions
Authorization: Bearer your-api-key
Content-Type: multipart/form-data

Տառադարձեք ձայնային ֆայլերը՝ օգտագործելով կազմաձևված ցանկացած STT մատակարար։ Ուղու առաջին հատվածն ընտրում է բնիկ մատակարարին (openai/…, deepgram/…)։ Այլ մատակարարի մոդելը վերաարտահանող դարպասներն օգտագործում են որակավորված նույնացուցիչ (openrouter/deepgram/nova-3)։

Հարցում՝

curl -X POST http://localhost:20128/v1/audio/transcriptions \
  -H "Authorization: Bearer your-api-key" \
  -F "file=@recording.mp3" \
  -F "model=openai/whisper-1"

Պատասխան՝

{
  "text": "Բարև, սա տառադարձված ձայնային բովանդակությունն է։",
  "task": "transcribe",
  "language": "en",
  "duration": 12.5
}

Մոդելների նույնացուցիչների օրինակներ՝ openai/whisper-1 (պահանջում է OpenAI բանալի), openrouter/deepgram/nova-3 (պահանջում է OpenRouter բանալի), deepgram/nova-3 (պահանջում է բնիկ Deepgram բանալի)։ Պարզ deepgram/nova-3 հարցումը չի օգտագործում OpenRouter։

Աջակցվող ձևաչափեր՝ mp3, wav, m4a, flac, ogg, webm։

Համատեղելիություն Ollama-ի հետ

Ollama-ի API ձևաչափն օգտագործող հաճախորդների համար՝

# Զրույցի վերջնակետ (Ollama ձևաչափ)
POST /v1/api/chat

# Մոդելների ցանկ (Ollama ձևաչափ)
GET /api/tags

Հարցումներն ավտոմատ կերպով փոխակերպվում են Ollama-ի և ներքին ձևաչափերի միջև։

Թոքեն պարունակող VS Code / առանց վերնագրի այլընտրանքային ուղիներ

Օգտագործեք այս այլընտրանքային ուղիները, երբ ինտեգրումը չի կարող ներարկել Authorization վերնագիր, և անհրաժեշտ է API բանալին ներկառուցել բազային URL-ի մեջ։

# OpenAI ոճի կատալոգի այլընտրանքային ուղի
GET /api/v1/vscode/{token}/
GET /api/v1/vscode/{token}/models

# OpenAI ոճի զրույցի այլընտրանքային ուղիներ
POST /api/v1/vscode/{token}/chat/completions
POST /api/v1/vscode/{token}/responses

# Ollama ոճի այլընտրանքային ուղիներ
POST /api/v1/vscode/{token}/api/chat
GET /api/v1/vscode/{token}/api/tags

Օրինակ՝

curl https://your-host.example/api/v1/vscode/YOUR_API_KEY/models
curl -X POST https://your-host.example/api/v1/vscode/YOUR_API_KEY/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"auto","messages":[{"role":"user","content":"բարև"}]}'

Նշումներ՝

Թոքեն պարունակող այլընտրանքային ուղիները վերօգտագործում են /v1/*-ի և /api/tags-ի նույն մշակիչները․ պատասխանների կառուցվածքները մնում են նույնը։
Նախընտրեք Authorization: Bearer ..., երբ հաճախորդն աջակցում է հատուկ վերնագրեր։
URL-ի վրա հիմնված թոքենները կարող են հայտնվել հակադարձ պրոքսիի մատյաններում, զննարկչի պատմության մեջ և OmniRoute-ից դուրս հեռաչափության տվյալներում։ Դրանք դիտարկեք որպես համատեղելիության տարբերակ, այլ ոչ թե նույնականացման լռելյայն ռեժիմ։

Հեռաչափություն

# Ստանալ ուշացման հեռաչափության ամփոփումը (p50/p95/p99՝ ըստ մատակարարի)
GET /api/telemetry/summary

Պատասխան՝

{
  "providers": {
    "claudeCode": { "p50": 245, "p95": 890, "p99": 1200, "count": 150 },
    "github": { "p50": 180, "p95": 620, "p99": 950, "count": 320 }
  }
}

Բյուջե

# Ստանալ բյուջեի կարգավիճակը բոլոր API բանալիների համար
GET /api/usage/budget

# Սահմանել կամ թարմացնել բյուջեն
POST /api/usage/budget
Content-Type: application/json

{
  "apiKeyId": "key-123",
  "dailyLimitUsd": 5.00,
  "weeklyLimitUsd": 30.00,
  "monthlyLimitUsd": 100.00,
  "warningThreshold": 0.8,
  "resetInterval": "monthly"
}

Սխեմայի նշումներ (setBudgetSchema)՝ apiKeyId-ն պարտադիր է․ dailyLimitUsd, weeklyLimitUsd կամ monthlyLimitUsd դաշտերից առնվազն մեկը պետք է զրոյից մեծ լինի։ Ընտրովի դաշտեր՝ warningThreshold (0–1), resetInterval (daily | weekly | monthly), resetTime (HH:MM)։ Հնացած {keyId, limit, period} կառուցվածքը վերադարձնում է 400 Bad Request։

Թոքենների սահմանաչափեր

Յուրաքանչյուր API բանալու համար սահմանվող թոքենային բյուջեներ (տարբերվում են վերևում նշված՝ USD-ի վրա հիմնված բյուջեից)։ Դրանք կիրառվում են անմիջապես հարցման մշակման ուղու վրա․ երբ բանալու ընթացիկ պատուհանի օգտագործումը հասնում է սահմանաչափին, հարցումները մերժվում են 429 Too Many Requests պատասխանով։ Սահմանաչափերը կարող են վերաբերել որոշակի model-ի, provider-ի կամ կիրառվել global կերպով ամբողջ բանալու համար․ երբ հարցմանը համապատասխանում են մի քանի սահմանաչափեր, կիրառվում է ամենախիստը։

# Ցուցադրել բանալու թոքենների սահմանաչափերը (ներառյալ ընթացիկ պատուհանի փաստացի օգտագործումը)
GET /api/usage/token-limits?apiKeyId=key-123

# Ստեղծել կամ թարմացնել թոքենների սահմանաչափ
POST /api/usage/token-limits
Content-Type: application/json

{
  "apiKeyId": "key-123",
  "scopeType": "model",
  "scopeValue": "openai/gpt-4o",
  "tokenLimit": 1000000,
  "resetInterval": "monthly",
  "enabled": true
}

# Ջնջել թոքենների սահմանաչափը՝ ըստ id-ի
DELETE /api/usage/token-limits?id=tl-abc

Սխեմայի նշումներ (setTokenLimitSchema)․ apiKeyId-ն ու scopeType-ը (model | provider | global) պարտադիր են։ scopeValue-ն անհրաժեշտ է, եթե scopeType-ը global չէ (օրինակ՝ մոդելի id՝ model տիրույթի համար, մատակարարի id՝ provider տիրույթի համար)։ tokenLimit-ը պետք է լինի դրական ամբողջ թիվ (տողից փոխակերպվող)։ Ընտրովի դաշտեր՝ id (ստեղծելու համար բաց թողեք, թարմացնելու համար տրամադրեք), resetInterval (daily | weekly | monthly, լռելյայն՝ monthly), resetTime (HH:MM), enabled (լռելյայն՝ true)։ GET պատասխաններում յուրաքանչյուր սահմանաչափ լրացվում է tokensUsed, remaining, windowStart, periodStartAt և nextResetAt դաշտերով։ Սա կառավարման դասի վերջնակետ է (նույնականացման պահանջը կենտրոնացված կերպով պարտադրվում է authz մշակման շղթայի կողմից)։

Հարցման մշակում

Հաճախորդը հարցում է ուղարկում /v1/*
Երթուղու մշակիչը կանչում է handleChat, handleEmbedding, handleAudioTranscription կամ handleImageGeneration
Մոդելը որոշվում է (ուղղակի provider/model կամ alias/combo)
Հավատարմագրերն ընտրվում են տեղային DB-ից՝ հաշվի հասանելիության զտմամբ
Չատի համար handleChatCore-ը ստուգում է իմաստային/ստորագրային քեշը և որոշում combo-ի սեղմման կարգավորումները
Երբ միացված է, կանխարգելիչ սեղմումն իրականացվում է մինչև մատակարարի ձևաչափի փոխակերպումը (lite, Caveman, RTK կամ շերտավորված)
Մատակարարի կատարիչը հարցումն ուղարկում է վերադաս ծառայությանը
Պատասխանը փոխակերպվում է հաճախորդի ձևաչափին (չատի համար) կամ վերադարձվում է անփոփոխ (ներդրումների/պատկերների/ձայնի համար)
Օգտագործումը, սեղմման վերլուծական տվյալները և հարցումների մատյանները գրանցվում են
Սխալների դեպքում պահուստային տարբերակն կիրառվում է combo-ի կանոնների համաձայն

Ճարտարապետության ամբողջական տեղեկատու՝ ARCHITECTURE.md

Combo-ների կառավարում

Ավելի բարձր մակարդակի երթուղավորման combo-ները (որոնք արդեն ամփոփված են /api/combos* բաժնում) կարող են նաև 1:1 համապատասխանեցվել մոդելի id-ի ձևանմուշից՝ թույլ տալով OpenAI ոճի մոդելի id-ն աննկատ վերահղել դեպի combo։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/model-combo-mappings`	Ցուցադրել բոլոր model→combo համապատասխանեցումները
POST	`/api/model-combo-mappings`	Ստեղծել համապատասխանեցում — մարմին՝ `{pattern, comboId, priority?, enabled?, description?}`
GET	`/api/model-combo-mappings/[id]`	Ստանալ մեկ համապատասխանեցում
PUT	`/api/model-combo-mappings/[id]`	Թարմացնել գոյություն ունեցող համապատասխանեցման դաշտերը
DELETE	`/api/model-combo-mappings/[id]`	Հեռացնել համապատասխանեցումը

Նույնականացում․ կառավարման աշխատաշրջան/API բանալի (requireManagementAuth)։

Վեբհուքներ

OmniRoute-ի իրադարձությունների համար ելքային վեբհուքների բաժանորդագրություններ (հարցման ավարտ, քվոտայի սպառում, բանալու ռոտացիա և այլն)։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/webhooks`	Ցուցադրել վեբհուքները (գաղտնիքները քողարկվում են որպես `<prefix>...`)
POST	`/api/webhooks`	Ստեղծել վեբհուք — մարմին՝ `{url, events?: ["*"], secret?, description?}`
GET	`/api/webhooks/[id]`	Ստանալ վեբհուքը
PUT	`/api/webhooks/[id]`	Թարմացնել url/events/secret/description դաշտերը
DELETE	`/api/webhooks/[id]`	Հեռացնել վեբհուքը
POST	`/api/webhooks/[id]/test`	Ուղարկել փորձնական տվյալների փաթեթ վեբհուքի URL-ին և վերադարձնել առաքման կարգավիճակը

Նույնականացում՝ կառավարման աշխատաշրջան/API բանալի (requireManagementAuth)։

Գրանցված բանալիներ (ավտոմատ կառավարում)

Օգտագործվում է բանալիների ավտոմատ կառավարման ենթահամակարգի կողմից՝ հիմքում ընկած մատակարարի/հաշվի համար API բանալիներ տրամադրելու և ռոտացիայի ենթարկելու նպատակով՝ օրական/ժամային քվոտաներով։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/v1/registered-keys`	Ցուցադրել գրանցված բանալիները (միայն քողարկված նախածանցը)
POST	`/api/v1/registered-keys`	Տրամադրել նոր գրանցված բանալի — մարմին՝ `{name, provider?, accountId?, idempotencyKey?, expiresAt?, dailyBudget?, hourlyBudget?}`։ Չմշակված բանալին վերադարձվում է միայն մեկ անգամ։ Քվոտայի պատճառով մերժման դեպքում վերադարձվում է `429`։
GET	`/api/v1/registered-keys/[id]`	Ստանալ գրանցված բանալու մետատվյալները (առանց չմշակված բանալու տվյալների)
DELETE	`/api/v1/registered-keys/[id]`	Չեղարկել գրանցված բանալին
POST	`/api/v1/registered-keys/[id]/revoke`	Բացահայտ չեղարկման վերջնակետ (նույն ազդեցությունն ունի, ինչ DELETE-ը)

Նույնականացում՝ Bearer API բանալի (isAuthenticated)։ Տե՛ս նաև /v1/quotas/check և /v1/issues/report։

Գործակալների արձանագրություն

Ամպային գործակալների առաջադրանքներ (Claude Code, Codex Cloud, OpenHands և այլն), որոնք հեռակա կարգով կատարվում են OmniRoute-ի օգտատերերի անունից։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/v1/agents/tasks`	Առաջադրանքների ցանկ — ոչ պարտադիր `?provider=`, `?status=`, `?limit=` (1–500, լռելյայն՝ 50)
POST	`/api/v1/agents/tasks`	Ստեղծել առաջադրանք — հարցման մարմինը վավերացվում է `CreateCloudAgentTaskSchema`-ով (`providerId`, `prompt`, `source`, `options?`)։ Վերադարձնում է `201`՝ առաջադրանքի փաթեթով
DELETE	`/api/v1/agents/tasks?id=...`	Ջնջել առաջադրանքը
GET	`/api/v1/agents/tasks/[id]`	Կարդալ առաջադրանքը — համաժամանակ թարմացնում է կարգավիճակը վերին մակարդակի ամպային գործակալից, երբ `external_id`-ը սահմանված է
POST	`/api/v1/agents/tasks/[id]`	Տարբերակված գործողություն՝ `{action: "approve"}`, `{action: "message", message}` կամ `{action: "cancel"}`
DELETE	`/api/v1/agents/tasks/[id]`	Ջնջել որոշակի առաջադրանք՝ ըստ id-ի

Նույնականացում․ յուրաքանչյուր մեթոդի համար պահանջվում է կառավարման նույնականացում (requireCloudAgentManagementAuth)։ Մինչև v3.8.0 տարբերակը դրանք նույնականացում չէին պահանջում. անհամատեղելի փոփոխության համար տե՛ս 588a0333 կոմիթը։

# Ստեղծել Claude Code ամպային առաջադրանք
curl -X POST http://localhost:20128/api/v1/agents/tasks \
  -H "Authorization: Bearer your-management-key" \
  -H "Content-Type: application/json" \
  -d '{"providerId":"claude-code-cloud","prompt":"Fix the failing test","source":{"repo":"...","branch":"..."}}'

Կառավարման պրոքսիներ

Ելքային HTTP(S)/SOCKS պրոքսիներ, որոնք կարող են նշանակվել մատակարարներին, հաշիվներին կամ գլոբալ մակարդակով։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/v1/management/proxies`	Պրոքսիների ցանկ (`?id=`-ի դեպքում վերադարձնում է մեկը, իսկ `?id=&where_used=1`-ի դեպքում՝ նշանակումների գրաֆը)
POST	`/api/v1/management/proxies`	Ստեղծել պրոքսի — հարցման մարմինը վավերացվում է `createProxyRegistrySchema`-ով
PATCH	`/api/v1/management/proxies`	Թարմացնել պրոքսին — հարցման մարմինը վավերացվում է `updateProxyRegistrySchema`-ով (պահանջվում է `id`)
DELETE	`/api/v1/management/proxies?id=...&force=1`	Ջնջել պրոքսին (նշանակումներն անջատելու համար օգտագործեք `force=1`)
GET	`/api/v1/management/proxies/assignments`	Նշանակումների ցանկ — զտելի է ըստ `proxy_id`, `scope`, `scope_id` դաշտերի․ փոխանցեք `resolve_connection_id=<id>`՝ կապի ակտիվ պրոքսին որոշելու համար
PUT	`/api/v1/management/proxies/assignments`	Նշանակել — հարցման մարմինը վավերացվում է `proxyAssignmentSchema`-ով (`{scope, scopeId?, proxyId?}`)։ Մաքրում է դիսպետչերի քեշը
PUT	`/api/v1/management/proxies/bulk-assign`	Զանգվածային նշանակում — հարցման մարմինը վավերացվում է `bulkProxyAssignmentSchema`-ով (`{scope, scopeIds[], proxyId?}`)
GET	`/api/v1/management/proxies/health?hours=24`	Պրոքսիի առողջության ամփոփ տվյալներ (հաջողությունների/ձախողումների քանակ, ուշացում)՝ ժամանակային պատուհանի ընթացքում

Նույնականացում․ յուրաքանչյուր երթուղու համար պահանջվում է կառավարման աշխատաշրջան/API բանալի (requireManagementAuth)։

Առաջադրանքի նկարագրության POST /api/v1/management/proxies/[id]/assignments և POST /api/v1/management/proxies/[id]/health հարցումները սպասարկվում են վերևում ցուցադրված հարթ /assignments և /health երթուղիներով. կոդային բազայում առանձին id-ով ենթաերթուղիներ չկան։

Դիմակայունություն (ընդլայնված)

OmniRoute-ը տրամադրում է ժամանակավոր խափանումների մշակման երեք անկախ մեխանիզմ․ ստորև նշված կառավարման վերջնակետերը թույլ են տալիս օպերատորներին կարդալ և վերասահմանել դրանք։

Շրջանակ	Վիճակի պահոց	Ընթերցում	Վերակայում / մաքրում
Մատակարարի անջատիչ	`domain_circuit_breakers` + օպերատիվ հիշողություն	`/api/monitoring/health`	`POST /api/resilience/reset`
Կապի սպասման ժամանակահատված	`rateLimitedUntil`՝ մատակարարի կապերի վրա	`/api/rate-limits`, `/api/providers/[id]`	(վերաակտիվանում է ըստ անհրաժեշտության․ մաքրեք մատակարարի PUT հարցման միջոցով)
Մոդելի արգելափակում	Օպերատիվ հիշողությունում մոդելի հասանելիության ռեեստր	`GET /api/resilience/model-cooldowns`	`DELETE /api/resilience/model-cooldowns`

PATCH /api/resilience-ն ընդունում է մատակարարի անջատիչի վերասահմանումներ providerBreaker.oauth և providerBreaker.apikey դաշտերում։ Յուրաքանչյուր պրոֆիլ աջակցում է degradationThreshold, failureThreshold և resetTimeoutMs դաշտերը․ նույն դաշտերը հասանելի են Կառավարման վահանակ → Կարգավորումներ → Դիմակայունություն բաժնում։

# Մաքրել մեկ մոդելի արգելափակումը
curl -X DELETE http://localhost:20128/api/resilience/model-cooldowns \
  -H "Cookie: auth_token=..." \
  -H "Content-Type: application/json" \
  -d '{"provider":"openai","model":"gpt-4o-mini"}'

# Մաքրել բոլոր արգելափակումները
curl -X DELETE http://localhost:20128/api/resilience/model-cooldowns \
  -H "Cookie: auth_token=..." \
  -d '{"all":true}'

Ամբողջական հայեցակարգային տեղեկանքի և անջատիչի լռելյայն արժեքների համար տե՛ս CLAUDE.md → «Դիմակայունության կատարման ժամանակի վիճակ»։

Հմտություններ

OmniRoute-ը հատուկ գործարկվող մշակիչներով ընդլայնելու հմտությունների շրջանակ, ինչպես նաև մարքեթփլեյսի ինտեգրումներ։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/skills`	Ցուցակագրել տեղադրված հմտությունները՝ `?q=`, `?mode=on\|off\|auto`, `?source=skillsmp\|skillssh\|local` զտիչներով և էջավորմամբ
GET	`/api/skills/[id]`	Ստանալ մեկ հմտություն
PUT	`/api/skills/[id]`	Թարմացնել հմտությունը (անուն, նկարագրություն, ռեժիմ, սխեմա, մշակիչ, պիտակներ)
DELETE	`/api/skills/[id]`	Ապատեղադրել հմտությունը
POST	`/api/skills/install`	Տեղադրել հմտություն չմշակված մանիֆեստից՝ հարցման մարմին՝ `{name, version, description, schema:{input, output}, handlerCode, apiKeyId?}`
GET	`/api/skills/executions`	Ցուցակագրել հմտությունների վերջին գործարկումները (մուտքային/ելքային տվյալներով և տևողությամբ աուդիտի հետագիծ)
GET	`/api/skills/marketplace?q=...`	Որոնում/հանրաճանաչների ցանկ SkillsMP մարքեթփլեյսից (պահանջվում է `skillsmpApiKey` կարգավորումը)
POST	`/api/skills/marketplace/install`	Տեղադրել հմտություն SkillsMP-ից՝ ըստ id-ի
GET	`/api/skills/skillssh?q=&limit=`	Որոնել skills.sh ռեեստրում
POST	`/api/skills/skillssh/install`	Տեղադրել հմտություն skills.sh-ից՝ ըստ id-ի

Նույնականացում․ կառավարման աշխատաշրջան/API բանալի։ Մարքեթփլեյսի որոնման երթուղիներն ընդունում են կա՛մ կառավարման նույնականացում, կա՛մ Bearer API բանալի (isAuthenticated)։

Հիշողություն

Զրույցների/փաստերի մշտական հիշողության պահոց՝ սահմանափակված ըստ API բանալու / աշխատաշրջանի։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/memory`	Հիշողությունների ցանկ — `?apiKeyId=`, `?type=`, `?sessionId=`, `?q=`՝ `offset/limit` կամ `page/limit` էջավորմամբ
POST	`/api/memory`	Ստեղծել հիշողություն — մարմինը վավերացվում է Zod-ի միջոցով՝ `{content, key, type?, sessionId?, apiKeyId?, metadata?, expiresAt?}`
GET	`/api/memory/[id]`	Ստանալ մեկ հիշողություն
DELETE	`/api/memory/[id]`	Ջնջել հիշողություն
GET	`/api/memory/health`	Հիշողության ենթահամակարգի վիճակ (ՏԲ կապակցում, ներդրումների բեքենդ, վեկտորային ինդեքսի կարգավիճակ)

Նույնականացում․ կառավարման աշխատաշրջան/API բանալի (requireManagementAuth)։ type թվարկում՝ FACTUAL, EPISODIC, SEMANTIC, PROCEDURAL (տե՛ս MemoryType-ը src/lib/memory/types.ts-ում)։

MCP սերվեր

OmniRoute-ը տրամադրվում է ներկառուցված Model Context Protocol սերվերով՝ 3 փոխադրման եղանակով (stdio, SSE, streamable-http) և սահմանափակված գործիքներով։ Ստորև նշված կառավարման վահանակի վերջնակետերը կարդում են կարգավիճակի/աուդիտի տվյալները և միջնորդում HTTP փոխադրումները։

| Մեթոդ | Ուղի | Նկարագրություն | | ------ | ---------------------- | ------------------------------------------------------------------------------------------------ | -------------------- | | GET | /api/mcp/status | Պարբերական ազդանշան, փոխադրում, առցանց վիճակ, վերջին կանչ, առաջատար գործիքներ, 24-ժամյա հաջողության ցուցանիշ | | GET | /api/mcp/tools | MCP գործիքների ցանկ՝ name, description, scopes, phase, auditLevel, sourceEndpoints դաշտերով | | GET | /api/mcp/sse | Բացել SSE հոսք SSE փոխադրման համար (վերադարձնում է 503, եթե MCP-ն անջատված է կամ փոխադրումը չի համապատասխանում) | | POST | /api/mcp/sse | Ուղարկել JSON-RPC ֆրեյմ SSE փոխադրմամբ | | GET | /api/mcp/stream | Բացել Streamable HTTP փոխադրման SSE կողմը (սերվերի կողմից նախաձեռնված հաղորդագրություններ) | | POST | /api/mcp/stream | Ուղարկել JSON-RPC ֆրեյմ Streamable HTTP փոխադրմամբ | | DELETE | /api/mcp/stream | Ավարտել Streamable HTTP աշխատաշրջանը | | GET | /api/mcp/audit | Հարցում կատարել աուդիտի մատյանում — ?limit=, ?offset=, ?tool=, ?success=true | false, ?apiKeyId= | | GET | /api/mcp/audit/stats | Աուդիտի ամփոփ վիճակագրություն (ընդհանուր քանակներ, հաջողության ցուցանիշ, միջին տևողություն, առաջատար գործիքներ) |

Նույնականացում․ sse/stream փոխադրումները կիրառում են MCP-ին հատուկ նույնականացման մեխանիզմը (mcp շրջանակով Bearer API բանալի), իսկ status/tools/audit* երթուղիները հասանելի են կառավարման վահանակից ընթերցման համար (կառավարման վահանակի հոսթին հասանելիությունից բացի լրացուցիչ նույնականացում չի պահանջվում)։

Երկու HTTP փոխադրումներն էլ վերահսկվում են settings.mcpEnabled-ով և settings.mcpTransport-ով․ փոխադրման անհամապատասխանության դեպքում վերադարձվում է 400, իսկ MCP-ի անջատված վիճակի դեպքում՝ 503։

A2A սերվեր

OmniRoute-ը տրամադրում է A2A (Agent-to-Agent) JSON-RPC 2.0 վերջնակետ, ինչպես նաև REST փաթեթավորիչ՝ զննման/վահանակի օգտագործման համար։

JSON-RPC

POST /a2a
Authorization: Bearer your-api-key   # պարտադիր չէ, եթե OMNIROUTE_API_KEY-ը սահմանված չէ
Content-Type: application/json

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "message/send",
  "params": {
    "skill": "smart-routing",
    "messages": [{"role": "user", "content": "Route this coding task"}]
  }
}

Աջակցվող մեթոդներ (բոլորը կախված են settings.a2aEnabled-ից).

Մեթոդ	Նկարագրություն
`message/send`	Հմտության համաժամանակյա կատարում․ վերադարձնում է `{task, artifacts, metadata}`
`message/stream`	Նույն հմտությունների հավաքածուի հոսքային SSE կատարում
`tasks/get`	Ստանալ առաջադրանքն ըստ `taskId`-ի
`tasks/cancel`	Չեղարկել առաջադրանքն ըստ `taskId`-ի

Ներկառուցված հմտություններ՝ smart-routing, quota-management, provider-discovery, cost-analysis, health-report։

Գործակալի քարտ

GET /.well-known/agent.json

Վերադարձնում է հանրային A2A գործակալի քարտը (անուն, նկարագրություն, հնարավորություններ, հմտությունների կատալոգ, նույնականացման սխեմա)՝ հանրային քեշավորմամբ 1 ժամով։ Նույնականացում չի պահանջվում։

REST օժանդակ վերջնակետեր

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/a2a/status`	A2A-ի միացված լինելը + առաջադրանքների վիճակագրություն + քեշավորված գործակալի քարտի ամփոփագիր
GET	`/api/a2a/tasks`	Առաջադրանքների ցանկ — `?state=submitted\|working\|completed\|failed\|cancelled`, `?skill=`, `?limit=` (≤200), `?offset=`
POST	`/api/a2a/tasks`	(Իրականացված չէ որպես REST օժանդակ վերջնակետ․ ստեղծեք JSON-RPC `message/send`-ի միջոցով)
GET	`/api/a2a/tasks/[id]`	Ստանալ մեկ առաջադրանք
POST	`/api/a2a/tasks/[id]/cancel`	Չեղարկել առաջադրանքը

Նույնականացում․ REST օժանդակ վերջնակետերն աշխատում են առանց կառավարման նույնականացման (ընթեռնելի են վահանակից), իսկ JSON-RPC /a2a երթուղին օգտագործում է Bearer OMNIROUTE_API_KEY, եթե այն կազմաձևված է։

Ամպ, գնահատման թեստեր և գնահատում

| Մեթոդ | Ուղի | Նկարագրություն | | ------ | ------------------------------- | ------------------------------------------------------------------------------------------------- | ----------------------------- | ----------------------------------- | | POST | /api/cloud/auth | Ստուգել Bearer բանալին և վերադարձնել քողարկված մատակարարի կապերը + մոդելների կեղծանունները՝ ամպային համաժամացման սպասառուների համար | | POST | /api/cloud/credentials/update | Թարմացնել ամպի հետ համաժամացված մատակարարի գաղտնագրված հավատարմագրերը | | POST | /api/cloud/model/resolve | Տրամաբանական մոդելի նույնացուցիչը համապատասխանեցնել կոնկրետ մատակարարի/մոդելի՝ օգտագործելով տեղային երթուղավորման աղյուսակը | | GET | /api/cloud/models/alias | Ցուցակել մոդելների կեղծանունները՝ ամպային համաժամացմանը հասանելի տեսքով | | GET | /api/assess | Կարդալ վերջին գնահատման դասակարգումները (ըստ մատակարարի/մոդելի) | | POST | /api/assess | Գործարկել գնահատում — մարմին՝ {scope: {type:"all"} | {type:"provider", providerId} | {type:"model", modelId}, trigger?} | | GET | /api/evals | Ցուցակել ներկառուցված գնահատման թեստերի հավաքածուները + ամենավերջին գործարկումները | | POST | /api/evals | Սկսել գնահատման թեստի գործարկում | | POST | /api/evals/suites | Ստեղծել հատուկ գնահատման թեստերի հավաքածու — մարմինը վավերացվում է evalSuiteSaveSchema-ով | | GET | /api/evals/suites/[id] | Ստանալ հատուկ գնահատման թեստերի հավաքածուն |

Նույնականացում․ /api/cloud/auth-ն ուղղակիորեն վավերացնում է Bearer բանալին, իսկ մյուս /api/cloud/*, /api/evals/* և /api/assess երթուղիները պահանջում են կառավարման նստաշրջան/API բանալի։ /api/assess POST-ն օգտագործում է validateBody՝ տարբերակիչ միավորմամբ տիրույթի սխեմայի հետ։

ACP-ի (Agent Client Protocol) կառավարում

որպես դուստր պրոցեսներ։ Այս վերջնակետերը կառավարում են ACP գործակալների հայտնաբերումը և հատուկ գործակալների գրանցումը։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/acp/agents`	Ցուցակագրել բոլոր հայտնի CLI գործակալները (ներկառուցված + հատուկ)՝ տեղադրման կարգավիճակով, տարբերակով և գործարկվող ֆայլով
POST	`/api/acp/agents`	Գրանցել հատուկ ACP գործակալ կամ թարմացնել քեշը — հարցման մարմին՝ `{id, name, binary, versionCommand, providerAlias, spawnArgs, protocol}` կամ `{action: "refresh"}`
DELETE	`/api/acp/agents`	Հեռացնել հատուկ ACP գործակալ — հարցման պարամետր՝ `?id=<agentId>`

Պատասխանի օրինակ (GET /api/acp/agents)․

{
  "agents": [
    {
      "id": "claude",
      "name": "Claude Code CLI",
      "binary": "claude",
      "version": "1.0.45",
      "installed": true,
      "protocol": "stdio",
      "providerAlias": "claude",
      "isCustom": false
    },
    {
      "id": "my-custom-cli",
      "name": "My Custom CLI",
      "installed": false,
      "protocol": "stdio",
      "providerAlias": "my-provider",
      "isCustom": true
    }
  ],
  "cacheTtlMs": 60000,
  "cacheAge": 1234
}

Նույնականացում․ Պահանջվում է կառավարման աշխատաշրջան (վահանակի auth_token cookie) կամ կառավարման տիրույթով API բանալի։

Ամբողջական մանրամասների համար տե՛ս ACP Framework։

Վերլուծություն և դիտարկելիություն

Երթուղավորումը, սեղմումը և մատակարարների բազմազանությունը մշտադիտարկելու իրական ժամանակի վերլուծական վերջնակետեր։ Դրանք ապահովում են /dashboard/analytics/* էջերի աշխատանքը։

Ավտոմատ երթուղավորման վերլուծություն

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/analytics/auto-routing`	Ավտոմատ երթուղավորման համախմբված վիճակագրություն՝ կանչերի ընդհանուր քանակ, ռազմավարությունների բաշխում, մակարդակների բաշխում, առաջատար մատակարարներ
GET	`/api/analytics/auto-routing?days=7`	Ժամանակային պատուհանով վիճակագրություն (լռելյայն՝ 24 ժ)

Պատասխանի օրինակ․

{
  "window": "24h",
  "totalCalls": 1234,
  "strategyBreakdown": {
    "rules": 800,
    "cost": 200,
    "latency": 150,
    "sla-aware": 50,
    "lkgp": 34
  },
  "tierBreakdown": {
    "ultra": 100,
    "pro": 500,
    "standard": 400,
    "free": 234
  },
  "topProviders": [
    { "provider": "openai", "calls": 500, "avgLatencyMs": 850 },
    { "provider": "anthropic", "calls": 300, "avgLatencyMs": 1200 }
  ]
}

Սեղմման վերլուծություն

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/analytics/compression`	Սեղմման համախմբված վիճակագրություն՝ խնայված թոքեններ, խնայողության %, ռեժիմների բաշխում, շարժիչների օգտագործում

Պատասխանի օրինակ․

{
  "window": "24h",
  "totalOriginalTokens": 5000000,
  "totalCompressedTokens": 3500000,
  "totalSavings": 1500000,
  "savingsPct": 30.0,
  "modeBreakdown": {
    "lite": 400,
    "standard": 600,
    "aggressive": 100,
    "ultra": 50,
    "rtk": 84
  },
  "engineBreakdown": {
    "caveman": 800,
    "rtk": 434
  }
}

Մատակարարների բազմազանության հետևում

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/analytics/diversity`	Շենոնի էնտրոպիայի վրա հիմնված բազմազանության հետևում՝ կանխում է խափանման եզակի կետերը՝ չափելով մատակարարների բաշխվածությունը

Պատասխանի օրինակ․

{
  "window": "24h",
  "shannonEntropy": 2.45,
  "maxEntropy": 3.17,
  "diversityRatio": 0.77,
  "providerUsage": {
    "openai": 0.4,
    "anthropic": 0.25,
    "google": 0.2,
    "kiro": 0.15
  },
  "warnings": ["OpenAI accounts for 40% of traffic — consider diversifying"]
}

Նույնականացում․ Պահանջվում է կառավարման աշխատաշրջան կամ կառավարման տիրույթով API բանալի։

Ադմինիստրատիվ գործողություններ

Միայն ադմինիստրատորների համար նախատեսված վերջնակետեր՝ գործառնական կառավարման համար։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/admin/concurrency`	Կարդալ զուգահեռության ընթացիկ սահմանաչափերը (ընդհանուր + ըստ մատակարարի)
POST	`/api/admin/concurrency`	Թարմացնել զուգահեռության սահմանաչափերը — մարմին՝ `{global?: number, perProvider?: Record<string, number>}`

Նույնականացում՝ Պահանջվում է ադմինիստրատորի շրջանակով կառավարման աշխատաշրջան։

CLI գործիքների կառավարում

Կառավարեք OmniRoute-ի հետ ինտեգրվող CLI գործիքները (antigravity, commandCode, devin-cli և այլն)։ Ամբողջական ցանկը տեսեք Մատակարարների տեղեկատուում։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/cli-tools/all-statuses`	Բոլոր CLI գործիքների կարգավիճակը (տեղադրված լինելը, տարբերակը, վերջին հայտնաբերումը)
GET	`/api/cli-tools/status`	Մեկ CLI գործիքի կարգավիճակի մանրամասները (`?tool=` հարցում)
POST	`/api/cli-tools/apply`	Գրանցում է գործիքի ստեղծված կազմաձևը (`dryRun`-ը ցուցադրում է նախադիտումը, կոնտեյներացված լինելու դեպքում՝ `422` + `containerEphemeralTarget`, իսկ `migration`-ը նշում է հնացած Codex YAML-ը)
GET	`/api/cli-tools/backups`	Ցուցադրում է CLI գործիքների կազմաձևերի պահուստային պատճենները
POST	`/api/cli-tools/backups`	Ստեղծում է բոլոր CLI գործիքների կազմաձևերի պահուստային պատճենը
POST	`/api/cli-tools/backups`	Վերականգնում․ նույն վերջնակետը, երբ հարցման մարմնում փոխանցվում է `{tool, backupId}`, վերականգնում է այդ պահուստային պատճենը
GET	`/api/cli-tools/antigravity-mitm`	Antigravity MITM պրոքսիի կարգավիճակը («antigravity-mitm» CLI գործիք)
POST	`/api/cli-tools/antigravity-mitm/alias`	Կազմաձևում է antigravity-mitm կեղծանունները

Նույնականացում․ Պահանջվում է կառավարման աշխատաշրջան։

Գործակալների հմտություններ

Կառավարեք ԱԲ գործակալների հմտությունները (նման են OpenAI-ի անհատականացված GPT-ներին, սակայն նախատեսված են գործակալների համար)։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/agent-skills`	Ցուցակել գործակալների բոլոր հմտությունները (ներկառուցված + անհատականացված)
GET	`/api/agent-skills/[id]`	Ստանալ գործակալի որոշակի հմտություն
POST	`/api/agent-skills`	Ստեղծել գործակալի անհատականացված հմտություն — մարմին՝ `{name, description, prompt, model?, temperature?}`
PUT	`/api/agent-skills/[id]`	Թարմացնել գործակալի անհատականացված հմտությունը
DELETE	`/api/agent-skills/[id]`	Ջնջել գործակալի անհատականացված հմտությունը
GET	`/api/agent-skills/[id]/raw`	Ստանալ չմշակված հրահանգը + մետատվյալները (առանց կատարման)
POST	`/api/agent-skills/generate`	Բնական լեզվով նկարագրությունից ԱԲ-ի միջոցով գեներացնել նոր հմտություն

Նույնականացում՝ Պահանջվում է կառավարման աշխատաշրջան կամ կառավարման շրջանակով API բանալի։

Քեշի կառավարում

Կառավարեք իմաստային քեշը և դատողությունների քեշը։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/cache`	Քեշի ակնարկ՝ գրառումների ընդհանուր քանակը, դիպումների գործակիցը, սկավառակի վրա զբաղեցրած չափը
GET	`/api/cache/entries`	Քեշավորված գրառումների ցանկ (էջավորմամբ)
DELETE	`/api/cache/entries`	Ջնջել քեշի գրառումները (զտել ըստ հարցման պարամետրերի)
GET	`/api/cache/stats`	Քեշի մանրամասն վիճակագրություն (ըստ մատակարարի, ըստ մոդելի)
GET	`/api/cache/reasoning`	Դատողությունների քեշի կարգավիճակը (դատողությունների վերարտադրման համար)
DELETE	`/api/cache/reasoning`	Մաքրել դատողությունների քեշը — հարցման պարամետրեր՝ `?toolCallId=<id>` (մեկը), `?provider=<p>` կամ առանց պարամետրերի (բոլորը)

Նույնականացում․ Պահանջվում է կառավարման աշխատաշրջան։

Հիշողության համակարգ

Կառավարեք մշտական հիշողությունը (FTS5 + վեկտորային ներդրումներ)։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/memory`	Հիշողության գրառումների ցանկ (զտել ըստ տիրույթի, տեսակի, որոնման հարցման)
POST	`/api/memory`	Ստեղծել հիշողության նոր գրառում — մարմին՝ `{scope, type, content, metadata?}`
GET	`/api/memory/[id]`	Ստանալ հիշողության որոշակի գրառում
PUT	`/api/memory/[id]`	Թարմացնել հիշողության գրառումը
DELETE	`/api/memory/[id]`	Ջնջել հիշողության գրառումը
GET	`/api/memory?q=`	Որոնել հիշողության մեջ (FTS5 + վեկտոր) — վիճակագրությունը ներառված է նույն պատասխանում

Նույնականացում․ Պահանջվում է կառավարման աշխատաշրջան կամ կառավարման տիրույթով API բանալի։

Webhook-ներ

Կառավարեք իրադարձությունների webhook բաժանորդագրությունները։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/webhooks`	Բոլոր webhook բաժանորդագրությունների ցանկը
POST	`/api/webhooks`	Ստեղծել webhook բաժանորդագրություն — մարմին՝ `{url, events[], secret?, active?}`
GET	`/api/webhooks/[id]`	Ստանալ որոշակի webhook բաժանորդագրություն
PUT	`/api/webhooks/[id]`	Թարմացնել webhook բաժանորդագրությունը
DELETE	`/api/webhooks/[id]`	Ջնջել webhook բաժանորդագրությունը
GET	`/api/webhooks/[id]/deliveries`	Ստանալ webhook-ի առաքումների պատմությունը (հաջողության/ձախողման մատյան)
POST	`/api/webhooks/[id]/test`	Ուղարկել փորձնական իրադարձություն webhook-ին

Նույնականացում․ Պահանջվում է կառավարման աշխատաշրջան։

Իրադարձությունների տեսակների ամբողջական ցանկի համար տե՛ս Webhook-ների հենքը։

Հմտությունների շրջանակ

Կառավարեք հմտությունները (ագենտային ընդլայնումների շրջանակը)։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/skills`	Ցուցադրել բոլոր տեղադրված հմտությունները (ներկառուցված + անհատական)
POST	`/api/skills/install`	Տեղադրել հմտություն տեղային ուղուց կամ URL-ից
DELETE	`/api/skills/[id]`	Ապատեղադրել հմտությունը
PUT	`/api/skills/[id]`	Միացնել կամ անջատել հմտությունը — մարմին՝ `{enabled?: boolean, mode?: "on" \| "off" \| "auto"}`
POST	`/api/skills/executions`	Կատարել հմտությունը — մարմին՝ `{skillName, apiKeyId, input?, sessionId?}`
GET	`/api/skills/executions`	Ցուցադրել բոլոր հմտությունների կատարման պատմությունը (զտել ըստ `?apiKeyId=`-ի)

Նույնականացում՝ պահանջվում է կառավարման աշխատաշրջան կամ կառավարման տիրույթով API բանալի։

Ամբողջական մանրամասների համար տե՛ս Հմտությունների շրջանակ։

Փլագիններ

Կառավարեք OmniRoute-ի փլագինները (երրորդ կողմի ընդլայնումները)։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/plugins`	Ցուցադրել տեղադրված փլագինները
POST	`/api/plugins/marketplace/install`	Տեղադրել փլագին շուկայից
DELETE	`/api/plugins/[name]`	Ապատեղադրել փլագինը
POST	`/api/plugins/[name]/activate`	Ակտիվացնել փլագինը
POST	`/api/plugins/[name]/deactivate`	Ապաակտիվացնել փլագինը
GET	`/api/plugins/[name]/config`	Ստանալ փլագինի կազմաձևումը
PUT	`/api/plugins/[name]/config`	Թարմացնել փլագինի կազմաձևումը

Նույնականացում՝ պահանջվում է կառավարման աշխատաշրջան։

Ամբողջական մանրամասների համար տե՛ս Փլագինների շրջանակ։

Ստվերային երթուղավորում

Պրովայդերների ստվերային / A-B համեմատությունը ինքնուրույն REST մակերես չէ. այն կազմաձևվում է համակցված երթուղավորման միջոցով (տե՛ս Ավտոմատ համակցում)։ Յուրաքանչյուր համակցության համեմատական չափորոշիչները տրամադրվում են GET /api/combos/metrics-ի միջոցով։

Պաշտպանական սահմանափակումներ

Դիտարկեք կատարման միջավայրի պաշտպանական սահմանափակումները (PII-ի հայտնաբերում, պրոմփթի ներարկման հայտնաբերում, տեսողական կապակցում)։ Պաշտպանական սահմանափակումները գործարկվում են յուրաքանչյուր հարցման ժամանակ։ Յուրաքանչյուր կանչի համար դրանցից հրաժարումը կատարվում է հարցման x-omniroute-disabled-guardrails վերնագրի միջոցով. միացման/անջատման պահպանվող մակերես չկա։

Մեթոդ	Ուղի	Նկարագրություն
GET	`/api/guardrails`	Ցուցադրել գրանցված պաշտպանական սահմանափակումներն ու դրանց կարգավիճակը (անուն / միացվածություն / առաջնահերթություն)
POST	`/api/guardrails/test`	Փորձնական մուտքի վրա նախականչային խողովակաշարի չոր գործարկում — մարմին՝ `{input, disabledGuardrails?}`

Նույնականացում՝ պահանջվում է կառավարման աշխատաշրջան։

Ամբողջական մանրամասների համար տե՛ս Անվտանգություն > Պաշտպանական սահմանափակումներ։

Նույնականացում

Չորս տեսակի հավատարմագրերի (կառավարման վահանակի աշխատաշրջան, տեղային CLI թոքեն, oma_live_… հասանելիության թոքեն, կառավարման շրջանակով API բանալի) և եզրակացության բանալիներից դրանց տարբերությունների մասին տե՛ս Կառավարման նույնականացում։

Կառավարման վահանակի երթուղիները (/dashboard/*) օգտագործում են auth_token cookie
Մուտք գործելիս օգտագործվում է պահպանված գաղտնաբառի հեշը, իսկ որպես պահուստային տարբերակ՝ INITIAL_PASSWORD
requireLogin-ը կարելի է միացնել կամ անջատել /api/settings/require-login-ի միջոցով
/v1/* երթուղիները կարող են պահանջել Bearer API բանալի, երբ REQUIRE_API_KEY=true
Այս տեղեկատուում «կառավարման թոքեն» / «կառավարման շրջանակով API բանալի» նշանակում է այդ ուղեցույցում նշված տեսակներից մեկը, այլ ոչ թե լրացուցիչ, չսահմանված գաղտնիքի տեսակ

Հետադարձ համատեղելիությունը խախտող փոփոխություն (v3.8.0) — /api/v1/agents/tasks/*-ը և հապաղման ժամանակահատվածի կառավարման վերջնակետերն այժմ պահանջում են կառավարման նույնականացում (կառավարման վահանակի auth_token cookie կամ կառավարման շրջանակով API բանալի)։ Այն հաճախորդները, որոնք նախկինում այս երթուղիները կանչում էին առանց նույնականացման, կստանան 401 Unauthorized։ Տե՛ս 588a0333 կոմիթը (fix(auth): require management auth for agent and cooldown APIs)։