mirror of https://github.com/diegosouzapw/OmniRoute.git synced 2026-09-18 12:52:25 +03:00

Files

Diego Rodrigues de Sa e Souza b637350680 fix(docs): re-sync the 65 documentation mirror sets; section-level docs pipeline; drift gate blocking (#13940 )

1,104 mirrors rewritten over five passes of run-translation on the 22-source core set: the 14 sources edited since their translation, the 322 mirrors that were still English copies, and the frontmatter the old extractor leaked into the newer locales' bodies. The pipeline now caches per-`## `-section hashes and retranslates only changed sections, never reuses a section that is still English, rebuilds English-copy / leaked mirrors even when the source is unchanged, merges the state on save (parallel runs), and the drift gate (scoped to the core set) is blocking. Final audit: 0 stale, 0 English copies, 0 leaked frontmatter across 1,430 core mirrors.

⚠️ base-red inherited: #12732

2026-09-17 02:55:31 -03:00

192 KiB

Raw Blame History

API Reference (తెలుగు)

🌐 Languages: 🇺🇸 English · 🇪🇹 am · 🇸🇦 ar · 🇦🇿 az · 🇧🇬 bg · 🇧🇩 bn · 🇨🇿 cs · 🇩🇰 da · 🇩🇪 de · 🇬🇷 el · 🇪🇸 es · 🇪🇪 et · 🇮🇷 fa · 🇫🇮 fi · 🇫🇷 fr · 🇮🇪 ga · 🇮🇳 gu · 🇳🇬 ha · 🇮🇱 he · 🇮🇳 hi · 🇭🇷 hr · 🇭🇺 hu · 🇦🇲 hy · 🇮🇩 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 · 🇹🇭 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`గా సెట్ చేయండి (నో-క్యాష్ను ప్రతిబింబిస్తుంది; ఒక్కో కాల్కు అయ్యే టోకెన్/వ్యయ అదనపు భారాన్ని నివారిస్తుంది)
`X-OmniRoute-Progress`	అభ్యర్థన	పురోగతి ఈవెంట్ల కోసం `true`గా సెట్ చేయండి
`X-Session-Id`	అభ్యర్థన	బాహ్య సెషన్ అనుబంధం కోసం స్టికీ సెషన్ కీ
`x_session_id`	అభ్యర్థన	అండర్స్కోర్ రూపాంతరం కూడా ఆమోదించబడుతుంది (ప్రత్యక్ష HTTP)
`X-OmniRoute-Session-Id`	అభ్యర్థన	కాలర్ అందించిన సెషన్/సంభాషణ ట్యాగ్ (మెమరీకి కూడా అందించబడుతుంది). ఇది ఉన్నప్పుడు, ప్రతి సెషన్ వ్యయ ఆపాదన కోసం `call_logs.session_tag`లో యథాతథంగా నిల్వ చేయబడుతుంది (#8249) — లేనప్పుడు ఎన్నడూ రూపొందించబడదు
`Idempotency-Key`	అభ్యర్థన	నకలు తొలగింపు కీ (5s విండో)
`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`	ప్రతిస్పందన	HITలో క్యాష్ ఆదా చేసిన USD (క్యాష్ హిట్లకు మాత్రమే)
`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 (ఫెయిల్-ఓపెన్).

క్యాష్-హిట్ వ్యయ అర్థవివరణ: సెమాంటిక్-క్యాష్ HIT (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ను అందుబాటులో ఉంచుతాయి, కానీ ఎంచుకున్న కనెక్షన్ లేదా క్రెడెన్షియల్లను ఎప్పటికీ వెల్లడించవు. పునరుద్ధరణ మరియు విడుదల కోసం 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 కీ మరియు ఖచ్చితమైన క్రియాశీల generation ద్వారా ఫెన్స్ చేయబడుతుంది. displayName అనేది ట్రిమ్ చేసిన కాన్ఫిగర్ చేసిన కనెక్షన్ పేరు మాత్రమే; సురక్షితమైన కాన్ఫిగర్ చేసిన పేరు ఏదీ లేనప్పుడు అది nullగా ఉంటుంది. OmniRoute ఎప్పుడూ దాని స్థానంలో ఇమెయిల్ లేదా రూపొందించిన ఖాతా గుర్తింపును ఉపయోగించదు. ప్రొవైడర్ విలువ సున్నితమైనది కాని ప్రదర్శన లేబుల్ మాత్రమే, అది ఎప్పటికీ రూపొందించిన అనుకూల-ప్రొవైడర్ ఐడెంటిఫయర్ కాదు. క్రెడెన్షియల్లు, టోకెన్లు, కుకీలు, ముడి కనెక్షన్ లేదా API కీ idలు, యజమాని హ్యాష్లు, ఫెన్సింగ్ సీక్రెట్లు మరియు అంతర్గత రూటింగ్ డేటా మినహాయించబడతాయి.

తప్పు-కీ, తప్పు-యజమాని, కాలం చెల్లిన-generation, కనిపించని, గడువు ముగిసిన, విడుదల చేసిన మరియు చెల్లనిదిగా చేసిన లుకప్లు అన్నీ కనెక్షన్ మెటాడేటా లేకుండా ఒకే 409 LEASE_FENCE_STALE లోపాన్ని తిరిగి ఇస్తాయి. సామర్థ్యం కోసం వేచి ఉండే ప్రతిస్పందనను అందుకున్న క్లయింట్కు పరిశీలించడానికి క్రియాశీల బైండింగ్ ఉండదు. రూటింగ్ ఒక క్రియాశీల లీజ్ను మార్చినప్పుడు, అదే generation చెల్లుబాటులో ఉంటుంది మరియు స్థితి పాత బైండింగ్ను కాకుండా కొత్త బైండింగ్ను అటామిక్గా తిరిగి ఇస్తుంది. పొందడం, పునరుద్ధరించడం, విడుదల చేయడం మరియు వేచి ఉండే ప్రతిస్పందనలు వాటి మునుపటి ఆకృతులను కొనసాగిస్తాయి కాబట్టి ఇప్పటికే ఉన్న క్లయింట్లు మారవు.

ఈ సర్వర్ ఒప్పందం ప్రామాణిక OpenAI Codex /statusను మార్చదు. ప్రామాణిక Codex ప్రస్తుతం దాని మోడల్ ప్రొవైడర్ మరియు అంతర్నిర్మిత ప్రామాణీకరణ/ఖాతా స్థితిని నివేదిస్తుంది, కానీ ఏకపక్ష కస్టమ్ ప్రొవైడర్ ఖాతా మెటాడేటాను రెండర్ చేయదు; భవిష్యత్తు క్లయింట్ ఇంటిగ్రేషన్ ఈ చర్యను కాల్ చేసి, connection.displayNameను ఎలా ప్రదర్శించాలో నిర్ణయించాలి.

ఆ తర్వాత ప్రతి నిర్వహిత ఇన్ఫరెన్స్ అభ్యర్థన ఈ రెండు నియంత్రణ హెడర్లను అందిస్తుంది:

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

మద్దతు ఉన్న ప్రతి అప్స్ట్రీమ్ ప్రయత్నానికి వెంటనే ముందు ఖచ్చితమైన యజమాని, generation, క్రియాశీల కనెక్షన్ మరియు ప్రామాణీకరించిన API కీ ఫెన్స్ చేయబడతాయి. అదే కనెక్షన్కు మరొక కీ అనుమతి ఇచ్చినప్పటికీ, ఆ కీతో యజమాని మరియు generationను మళ్లీ ఉపయోగించడం విఫలమవుతుంది. ముడి యజమాని విలువలు నిల్వ చేయబడవు, లాగ్ చేయబడవు, అభ్యర్థన స్నాప్షాట్లో ఉంచబడవు లేదా అప్స్ట్రీమ్కు ఫార్వర్డ్ చేయబడవు.

తాత్కాలిక పోటీ Retry-Afterతో కూడిన HTTP 429ను మరియు కింది ప్రతిస్పందనను తిరిగి ఇస్తుంది:

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

ఈ ప్రతిస్పందన అర్థం సాధారణ అర్హత సెట్ ఖాళీగా లేదని మరియు ఖాళీగా ఉన్న ప్రతి అభ్యర్థిని ఇతర క్రియాశీల లీజ్ ఆక్రమించిందని మాత్రమే. మద్దతు లేని మోడల్లు/ప్రొవైడర్లు, పాలసీ అసమతుల్యత, కూల్డౌన్, కోటా, ఆరోగ్యం మరియు ఇతర సాధారణ అర్హత వైఫల్యాలు వాటి ప్రస్తుత OmniRoute ప్రతిస్పందనలను కొనసాగిస్తాయి.

`x-omniroute-compression`

కంప్రెషన్ ప్లాన్కు ప్రతి-అభ్యర్థన ఓవర్రైడ్. దీనికే అత్యధిక ప్రాధాన్యం — ఇది రూటింగ్-కాంబో ఓవర్రైడ్, క్రియాశీల ప్రొఫైల్, ఆటో-ట్రిగ్గర్ మరియు ప్యానెల్ Defaultను అధిగమిస్తుంది. విలువలు:

విలువ	ప్రభావం
`off`	ఈ అభ్యర్థనకు కంప్రెషన్ ఉండదు.
`default`	ప్యానెల్ నుంచి ఉత్పన్నమైన Default ప్రొఫైల్ (క్రియాశీల ప్రొఫైల్ను విస్మరిస్తుంది).
`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.

కేటలాగ్ idలు provider/model రూపంలో ఉంటాయి (ఉదాహరణ: jina-ai/jina-embeddings-v5-omni-small). రిజిస్ట్రీలో కనిపించే ప్రొవైడర్ పేరు లేని Jina మోడల్ idలు (ఉదాహరణకు 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 తనిఖీ తర్వాత యథాతథంగా ఫార్వర్డ్ చేయబడతాయి; URLను Jina ఫెచ్ చేస్తుంది.
ఇన్లైన్ base64 మీడియా ప్రతి అంశానికి డీకోడ్ చేసిన పరిమాణంలో 8 MiBకి, మొత్తం అభ్యర్థనకు డీకోడ్ చేసిన పరిమాణంలో 16 MiBకి పరిమితం చేయబడుతుంది.

ప్రొవైడర్ అనువాదం (ప్రామాణిక అంశాలు ఎప్పటికీ మార్పులు లేకుండా ఫార్వర్డ్ చేయబడవు):

Jina మల్టీమోడల్ మోడల్లు: ప్రతి అగ్ర-స్థాయి అంశం, ఇన్లైన్ మీడియా కోసం data URIలను ఉపయోగిస్తూ, ఒక మోడాలిటీ-కీడ్ ఆబ్జెక్ట్గా (text / image / audio / video / pdf) మారుతుంది; ప్రతి అగ్ర-స్థాయి అంశానికి ఒక వెక్టర్.
Gemini Embedding 2 ఫ్యామిలీ: ఒక అగ్ర-స్థాయి అరే, content.parts (text లేదా inline_data)తో కూడిన ఒకే స్థానిక models/{model}:embedContent అభ్యర్థనగా మారుతుంది.
స్పష్టమైన మోడాలిటీ మెటాడేటా లేని తెలియని/డైనమిక్ మోడల్లు నిర్మిత ఇన్పుట్ను 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, provider/model ప్రిఫిక్స్ ద్వారా OCR ప్రొవైడర్ను ఎంచుకుంటుంది; ప్రొవైడర్ లేని మోడల్ id (ఉదా. 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, చాట్/చిత్ర ట్రాఫిక్ కోసం OmniRoute ఇప్పటికే మద్దతిచ్చే అదే Vertex AI ప్రామాణీకరణను (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) జరుగుతాయి, ఆపై handleOcrకు పంపించే ముందు src/app/api/v1/ocr/route.ts వాటిని వినియోగిస్తుంది.

మోడళ్ల జాబితా

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

→ OpenAI ఆకృతిలోని అన్ని చాట్, ఎంబెడ్డింగ్ మరియు ఇమేజ్ మోడళ్లు + కాంబోలను అందిస్తుంది

మోడల్ id ప్రిఫిక్స్లు (`?prefix=`)

చాలా మోడళ్లు ప్రొవైడర్ ప్రిఫిక్స్ కింద ప్రకటించబడతాయి. మీకు ఏ ప్రిఫిక్స్ లభిస్తుందనేది MODELS_CATALOG_PREFIX_MODE ఫీచర్ ఫ్లాగ్ ద్వారా నియంత్రించబడుతుంది, అలాగే ప్రతి ఒక్కరి కోసం సర్వర్-వ్యాప్త సెట్టింగ్ను మార్చకుండానే శుభ్రమైన జాబితాను కోరుకునే క్లయింట్కు ఉపయోగపడే విధంగా, క్వెరీ పారామీటర్తో ప్రతి అభ్యర్థనకు దాన్ని ఓవర్రైడ్ చేయవచ్చు:

GET /v1/models?prefix=alias        # ప్రతి మోడల్కు ఒక id — సంక్షిప్త అలియాస్ ప్రిఫిక్స్
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`	ప్రతి మోడల్కు ఒక ఎంట్రీ. ప్రత్యేకమైన అలియాస్ లేని ప్రొవైడర్లు కూడా తమ ఎంట్రీని విడుదల చేస్తారు, కాబట్టి ఏదీ కోల్పోదు.
`canonical`	`claude/claude-sonnet-4-6`	పూర్తి ప్రొవైడర్-id ప్రిఫిక్స్ కింద ప్రతి మోడల్కు ఒక ఎంట్రీ. ప్రత్యేకమైన అలియాస్ లేని ప్రొవైడర్లు (ఉదా. `antigravity/…`, `agy/…`) కూడా ఇక్కడ తమ ఏకైక idని విడుదల చేస్తారు, కాబట్టి ఏదీ కోల్పోదు.

క్వెరీ పారామీటర్ లేకుండానే dual-మోడ్ మిర్రర్ను గుర్తించవచ్చు: ఇది ప్రాథమిక idని సూచించే parent ఫీల్డ్ను కలిగి ఉంటుంది.

మోడల్ పికర్ను రెండర్ చేసే క్లయింట్లు ?prefix=aliasను అభ్యర్థించాలి — OmniCopilot VS Code ఎక్స్టెన్షన్ ఇదే చేస్తుంది.

ఆలోచన-రహిత మోడల్ వేరియంట్లు

ఆలోచించే సామర్థ్యం ఉన్న Claude మోడళ్ల కోసం, /v1/models claude-3-omniroute-no-thinking/తో ప్రారంభమయ్యే id కలిగిన ఆలోచన-రహిత వేరియంట్ను కూడా ప్రకటిస్తుంది:

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

ఈ idని ఎంచుకోవడం (ఉదా. ఎల్లప్పుడూ thinking బ్లాక్ను జోడించే Claude Code కాన్ఫిగ్లో) రీజనింగ్ను అణచివేసి అసలైన <provider>/<model>కు తిరిగి పరిష్కరిస్తుంది — /v1/messages పాత్లో thinking:{type:"disabled"}, లేదా /v1/chat/completions పాత్లో reasoning/reasoning_effort ఫీల్డ్లు తొలగించబడతాయి. ఆలోచనకు మద్దతిచ్చే మరియు disabledను గౌరవించే Claude-కుటుంబ మోడళ్లకు మాత్రమే ఈ వేరియంట్ జాబితాలో చూపబడుతుంది (అందువల్ల, ఉదా. disabledను తిరస్కరించే adaptive-only మోడళ్లు మినహాయించబడతాయి). ఆపరేటర్లు ModelSpec.noThinkingAlias ద్వారా ప్రతి మోడల్కు ఈ వేరియంట్ను బలవంతంగా ఆన్ లేదా ఆఫ్ చేయవచ్చు.

ప్రొవైడర్ ప్లగిన్ మానిఫెస్ట్

GET /api/v1/provider-plugin-manifest

Bifrost, CLIProxyAPI మరియు భవిష్యత్ sidecar రౌటర్లు ఉపయోగించే JSON-సురక్షిత ప్రొవైడర్ ప్లగిన్ మానిఫెస్ట్ను అందిస్తుంది. ప్రతిస్పందన TypeScript ప్రొవైడర్ రిజిస్ట్రీ నుండి రూపొందించబడుతుంది మరియు OAuth క్లయింట్ సీక్రెట్లు, రన్టైమ్ ఎన్విరాన్మెంట్ రిజల్యూషన్, ఎగ్జిక్యూటర్ ఫంక్షన్లు, రిక్వెస్ట్ హెడర్లు మరియు ఖాతా డేటాను ఉద్దేశపూర్వకంగా మినహాయిస్తుంది.

sidecar ప్రక్రియ వెలుపల నడుస్తూ, open-sse/config/providerPluginManifestRegistry.tsను నేరుగా ఇంపోర్ట్ చేయలేనప్పుడు ఈ ఎండ్పాయింట్ను ఉపయోగించండి.

అనుకూలత ఎండ్పాయింట్లు

పద్ధతి	పాత్	ఫార్మాట్
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 (సవరణ/inpaint)
POST	`/v1/videos/generations`	OpenAI-శైలి వీడియో జనరేషన్
POST	`/v1/music/generations`	OpenAI-శైలి సంగీత జనరేషన్
POST	`/v1/audio/transcriptions`	OpenAI Audio (STT)
POST	`/v1/audio/speech`	OpenAI TTS (ఆడియో బాడీని అందిస్తుంది)
POST	`/v1/rerank`	Cohere/Voyage-శైలి రీర్యాంక్
POST	`/v1/classify`	Jina వర్గీకరణ (`api.jina.ai`)
POST	`/v1/segment`	Jina సెగ్మెంటర్ (`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 క్యాటలాగ్ అలియాస్
GET	`/api/v1/vscode/{token}/models`	OpenAI మోడల్స్ అలియాస్
POST	`/api/v1/vscode/{token}/chat/completions`	OpenAI టోకెనైజ్డ్ అలియాస్
POST	`/api/v1/vscode/{token}/responses`	OpenAI Responses టోకెనైజ్డ్ అలియాస్
POST	`/api/v1/vscode/{token}/api/chat`	Ollama టోకెనైజ్డ్ అలియాస్
GET	`/api/v1/vscode/{token}/api/tags`	Ollama ట్యాగ్స్ టోకెనైజ్డ్ అలియాస్

అన్ని POST రూట్లు ఒకే ఆకృతిని అనుసరిస్తాయి: Bearer your-api-key + Zod ద్వారా ధృవీకరించబడిన JSON బాడీ (v1RerankSchema, v1ModerationSchema, v1AudioSpeechSchema మొదలైనవి; src/shared/validation/schemas.ts చూడండి). స్కీమా ధృవీకరణ విఫలమైతే 4xx అందించబడుతుంది.

Authorization: Bearer ...ను జోడించలేని క్లయింట్ల కోసం, OmniRoute క్వెరీ-స్ట్రింగ్ అనుకూలత (?token=..., ?apiKey=..., ?api_key=..., ?key=...) ద్వారా లేదా క్రింద డాక్యుమెంట్ చేసిన ప్రత్యేక /api/v1/vscode/{token}/... ఎండ్పాయింట్ల ద్వారా URLలో API కీలను కూడా అంగీకరిస్తుంది.

# రీర్యాంక్
POST /v1/rerank      { "model": "jina-ai/jina-reranker-v3.5", "query": "...", "documents": ["..."] }

# Jina వర్గీకరణ (Foundation API క్రెడెన్షియల్స్)
POST /v1/classify    { "model": "jina-embeddings-v5-text-small", "input": ["..."], "labels": ["a", "b"] }

# Jina సెగ్మెంటర్
POST /v1/segment     { "content": "...", "return_chunks": true }

# Jina శోధన (s.jina.ai; ప్రొవైడర్ అలియాస్లు: jina-search, jina-ai, jina)
POST /v1/search      { "query": "...", "provider": "jina-search" }

# మోడరేషన్లు
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": "..." }

ప్రత్యేక ప్రొవైడర్ రూట్లు

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

ప్రొవైడర్ ప్రిఫిక్స్ లేకుంటే అది స్వయంచాలకంగా జోడించబడుతుంది. సరిపోలని మోడల్లు 400ను అందిస్తాయి.

Files API

బ్యాచ్ ఇన్పుట్/అవుట్పుట్ మరియు ఫైల్-పర్పస్ అప్లోడ్ల కోసం OpenAI-అనుకూల ఫైల్స్ ఎండ్పాయింట్.

పద్ధతి	పాత్	వివరణ
POST	`/v1/files`	ఫైల్ను అప్లోడ్ చేయండి (మల్టీపార్ట్: `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`	ముడి ఫైల్ బాడీని తిరిగి స్ట్రీమ్ చేయండి

ప్రామాణీకరణ: బేరర్ API కీ — getApiKeyRequestScope ద్వారా ఫైళ్లు ప్రతి API కీ పరిధిలో ఉంచబడతాయి. ఒక కీ తన స్వంత ఫైళ్లను మాత్రమే చూస్తుంది, డౌన్లోడ్ చేస్తుంది మరియు తొలగిస్తుంది; కీ లేని డ్యాష్బోర్డ్ సెషన్ మొత్తం ఇన్స్టాన్స్ను చదువుతుంది; యజమాని లేని ఫైల్కు (అనామక లేదా డ్యాష్బోర్డ్-సెషన్ అప్లోడ్) ప్రతి నాన్-సెషన్ కాలర్కు యాక్సెస్ నిరాకరించబడుతుంది. GET /v1/files, REQUIRE_API_KEY=false అయినప్పటికీ, ప్రతి టెనెంట్కు చెందిన ఫైళ్లను జాబితా చేయడానికి బదులుగా అనామక కాలర్ను — అలాగే సమర్పించిన కీ పరిష్కరించబడకపోతే దానిని కూడా — 401తో తిరస్కరిస్తుంది (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`	ప్రాసెసింగ్లో ఉన్న బ్యాచ్ను రద్దు చేయండి

ప్రామాణీకరణ: బేరర్ API కీ. ఫైళ్లకు వర్తించే అదే త్రిముఖ నియమం ప్రకారం బ్యాచ్లు ప్రతి API కీ పరిధిలో ఉంచబడతాయి: స్వంత కీకి మాత్రమే యాక్సెస్, డ్యాష్బోర్డ్ సెషన్కు ఇన్స్టాన్స్-వ్యాప్త యాక్సెస్, యజమాని లేని రికార్డులకు ప్రతి నాన్-సెషన్ కాలర్కు యాక్సెస్ నిరాకరణ (పొందడం, తొలగించడం, రద్దు చేయడం మరియు సృష్టించేటప్పుడు input_file_id తనిఖీ). REQUIRE_API_KEY=false అయినప్పటికీ, GET /v1/batches అనామక కాలర్ను 401తో తిరస్కరిస్తుంది.

Search API

వెబ్/శోధన ప్రొవైడర్ అబ్స్ట్రాక్షన్ (Tavily, Brave, Exa, Serper మొదలైనవి).

విధానం	మార్గం	వివరణ
GET	`/v1/search`	కాన్ఫిగర్ చేసిన శోధన ప్రొవైడర్లు + సామర్థ్యాలను జాబితా చేస్తుంది
POST	`/v1/search`	శోధన క్వెరీని అమలు చేస్తుంది — బాడీ `v1SearchSchema` ద్వారా ధృవీకరించబడుతుంది, క్యాషింగ్/కోఅలెసింగ్కు మద్దతు ఉంటుంది
GET	`/v1/search/analytics`	ప్రతి ప్రొవైడర్కు సంబంధించిన హిట్/లేటెన్సీ/క్యాష్ గణాంకాలు

ప్రామాణీకరణ: Bearer API కీ (extractApiKey + isValidApiKey). శోధన విధానం enforceApiKeyPolicy ద్వారా అమలు చేయబడుతుంది.

Web Fetch API

కాన్ఫిగర్ చేసిన వెబ్-ఫెచ్ ప్రొవైడర్ (Firecrawl, Jina Reader, Tavily Extract, TinyFish Fetch, Nimble Extract) ద్వారా URL నుండి కంటెంట్ను సంగ్రహిస్తుంది.

విధానం	మార్గం	వివరణ
POST	`/v1/web/fetch`	URLను ఫెచ్/స్క్రేప్ చేస్తుంది — బాడీ `v1WebFetchSchema` ద్వారా ధృవీకరించబడుతుంది

ప్రామాణీకరణ: Bearer API కీ (extractApiKey + isValidApiKey). విధానం enforceApiKeyPolicy ద్వారా అమలు చేయబడుతుంది.

కోటా-అవగాహనతో కూడిన ఫాల్బ్యాక్ (#8297): స్పష్టమైన provider ఇవ్వనప్పుడు, పూల్ (firecrawl → jina-reader → tavily-search → tinyfish → nimble-search)ను స్థిరమైన ప్రాధాన్య క్రమంలో (మొదటిదాన్ని ముందుగా నింపే విధంగా) పరిశీలిస్తారు — రేట్-లిమిట్కు గురైనప్పటికీ కాన్ఫిగర్ చేయబడిన ప్రొవైడర్ అభ్యర్థనను అక్కడితో నిలిపివేయకుండా దాటవేయబడుతుంది, అలాగే మళ్లీ ప్రయత్నించదగిన/కోటాకు సంబంధించిన అప్స్ట్రీమ్ వైఫల్యం (HTTP 429 ఎల్లప్పుడూ; Firecrawl/Tavily/TinyFish కోటా-శైలి ఉచిత స్థాయిలకు 402/403 — Jina Readerకు కాదు, అలాగే సాధారణ 400 తప్పు అభ్యర్థనకు ఎప్పుడూ కాదు) అభ్యర్థన సమయంలో ఇంకా ప్రయత్నించని, క్రెడెన్షియల్స్ ఉన్న తదుపరి ప్రొవైడర్కు మారుతుంది. పూల్లోని ప్రతి ప్రొవైడర్ అందుబాటులో లేకపోతే, మునుపటి సాధారణ 400కు బదులుగా ఎండ్పాయింట్ ఒకే 429ను (Retry-After హెడర్తో) అందిస్తుంది. స్పష్టమైన provider అభ్యర్థించబడితే, నిశ్శబ్ద ఫాల్బ్యాక్ ఉండదు — రేట్-లిమిట్కు గురైన లేదా విఫలమైన స్పష్టమైన ప్రొవైడర్ తన స్వంత లోపాన్ని అందిస్తుంది (రేట్-లిమిట్కు గురైతే 429, లేకపోతే అప్స్ట్రీమ్ స్థితి).

WebSocket స్ట్రీమింగ్

GET /v1/ws?handshake=1

WebSocket అప్గ్రేడ్ హ్యాండ్షేక్ను ధృవీకరిస్తుంది మరియు వైర్ ప్రోటోకాల్ ఉదాహరణ సందేశాలను (request, cancel) అందిస్తుంది. వాస్తవ WS ఫ్రేమ్లు Next.js రూట్ పట్టిక వెలుపల ఉన్న బండిల్ చేసిన WS సర్వర్ ద్వారా నిర్వహించబడతాయి.

ప్రామాణీకరణ: హ్యాండ్షేక్ సమయంలో Bearer API కీ.

WebSocket ద్వారా Responses API (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 కనెక్షన్ను ఎంచుకుని, wreq-js ట్రాన్స్పోర్ట్ ద్వారా wss://chatgpt.com/backend-api/codex/responsesకు టన్నెల్ చేస్తుంది. 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 అయినప్పుడు క్లయింట్ వైపు మోడల్ పేరును ధృవీకరిస్తుంది మరియు codex/gpt-5.5 వంటి ప్రొవైడర్-ప్రిఫిక్స్ కలిగిన idsను తిరస్కరిస్తుంది (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/config.tomlలో WebSocket మద్దతుతో కూడిన కస్టమ్ ప్రొవైడర్ను జోడించడం ద్వారా Codex CLIని OmniRoute వైపు మళ్లించండి (ఇప్పటికే ఉన్న కాన్ఫిగరేషన్ను మార్చకుండా ఉండటానికి ప్రత్యేక 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"                    # Feb 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తో ధ్రువీకరించబడుతుంది — ఇది requireManagementAuth వెనుకే ఉండే నిర్వహణ ఇంటర్ఫేస్ (/api/keys/…) కాదు.

సెమాంటిక్ క్యాష్

# క్యాష్ గణాంకాలను పొందండి
GET /api/cache/stats

# అన్ని క్యాష్లను క్లియర్ చేయండి
DELETE /api/cache/stats

ప్రతిస్పందన ఉదాహరణ:

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

లేటెన్సీ ప్రభావం

సెమాంటిక్ క్యాష్ HIT ప్రతిస్పందనను క్యాష్ నుంచి అప్స్ట్రీమ్ కాల్ లేకుండానే అందిస్తుంది, కాబట్టి నివేదించబడే 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/*, పబ్లిక్ auth/login మినహా) సాధారణ 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	మోడల్ ధరలు

వినియోగం & విశ్లేషణలు

Endpoint	పద్ధతి	వివరణ
`/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)

సెట్టింగ్లు

Endpoint	పద్ధతి	వివరణ
`/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` ఉంటుంది: ప్రోబ్-క్యాష్ స్కేలర్లు, `failed>0` అయినప్పుడు `failedConnections`, మరియు `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	నిర్వహణ ప్రామాణీకరణ/ప్రోబ్కు ముందు కఠినమైన విశ్వసనీయ-లూప్బ్యాక్ తనిఖీ; శుద్ధీకరించిన FFmpeg/ffprobe లభ్యత మరియు వెర్షన్లు (no-store)
`/api/modality-bridge/video/extract`	POST	అంతర్గత ప్రామాణీకరించిన విశ్వసనీయ-లూప్బ్యాక్ బైట్ బ్రోకర్; 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 SDK అనుకూలతను ఆశించే క్లయింట్ల కోసం ఈ ఎండ్పాయింట్లు Gemini API ఆకృతిని ప్రతిబింబిస్తాయి.

అంతర్గత / సిస్టమ్ 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/…) ఎంచుకుంటుంది. మరొక వెండర్ మోడల్ను తిరిగి ఎక్స్పోర్ట్ చేసే గేట్వేలు క్వాలిఫైడ్ idను (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": "Hello, this is the transcribed audio content.",
  "task": "transcribe",
  "language": "en",
  "duration": 12.5
}

మోడల్ idల ఉదాహరణలు: 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":"hello"}]}'

గమనికలు:

టోకెన్తో కూడిన అలియాస్లు /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) తప్పనిసరి. scopeType అనేది global అయితే తప్ప scopeValue తప్పనిసరి (ఉదా. model స్కోప్ కోసం మోడల్ id, provider స్కోప్ కోసం ప్రొవైడర్ id). 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 సెమాంటిక్/సిగ్నేచర్ క్యాష్ను తనిఖీ చేసి, కాంబో కంప్రెషన్ సెట్టింగ్లను పరిష్కరిస్తుంది
ప్రారంభ కంప్రెషన్ ప్రారంభించబడి ఉంటే, ప్రొవైడర్ అనువాదానికి ముందు అమలవుతుంది (lite, Caveman, RTK, లేదా స్టాక్డ్)
ప్రొవైడర్ ఎగ్జిక్యూటర్ అప్స్ట్రీమ్ అభ్యర్థనను పంపుతుంది
ప్రతిస్పందన తిరిగి క్లయింట్ ఫార్మాట్కు అనువదించబడుతుంది (చాట్) లేదా యథాతథంగా తిరిగి ఇవ్వబడుతుంది (ఎంబెడ్డింగ్లు/చిత్రాలు/ఆడియో)
వినియోగం, కంప్రెషన్ విశ్లేషణలు మరియు అభ్యర్థన లాగ్లు నమోదు చేయబడతాయి
లోపాలు సంభవించినప్పుడు కాంబో నియమాల ప్రకారం ఫాల్బ్యాక్ వర్తించబడుతుంది

పూర్తి ఆర్కిటెక్చర్ సూచన: ARCHITECTURE.md

కాంబో నిర్వహణ

ఉన్నత-స్థాయి రూటింగ్ కాంబోలను (/api/combos* కింద ఇప్పటికే సంగ్రహించబడినవి) మోడల్ id నమూనా నుండి 1:1గా కూడా మ్యాప్ చేయవచ్చు, తద్వారా OpenAI-శైలి మోడల్ idను కాంబోకు పారదర్శకంగా మళ్లించవచ్చు.

పద్ధతి	పాత్	వివరణ
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]`	మ్యాపింగ్ను తొలగించండి

Auth: నిర్వహణ సెషన్/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తో సమానమైన ప్రభావం)

ప్రామాణీకరణ: బేరర్ API కీ (isAuthenticated). /v1/quotas/check మరియు /v1/issues/report కూడా చూడండి.

ఏజెంట్ల ప్రోటోకాల్

OmniRoute వినియోగదారుల తరఫున రిమోట్గా అమలు చేయబడే క్లౌడ్ ఏజెంట్ టాస్క్లు (Claude Code, Codex Cloud, OpenHands మొదలైనవి).

పద్ధతి	పాత్	వివరణ
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]`	నైపుణ్యాన్ని అప్డేట్ చేస్తుంది (name, description, mode, schema, handler, tags)
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`	మెమరీ ఉపవ్యవస్థ ఆరోగ్యం (DB కనెక్టివిటీ, ఎంబెడింగ్స్ బ్యాకెండ్, వెక్టర్ ఇండెక్స్ స్థితి)

ప్రామాణీకరణ: నిర్వహణ సెషన్/API కీ (requireManagementAuth). type enum: FACTUAL, EPISODIC, SEMANTIC, PROCEDURAL (src/lib/memory/types.tsలోని MemoryType చూడండి).

MCP సర్వర్

OmniRoute, 3 రవాణాలతో (stdio, SSE, streamable-http) మరియు పరిధి-పరిమిత సాధనాలతో కూడిన అంతర్నిర్మిత Model Context Protocol సర్వర్ను అందిస్తుంది. దిగువ డ్యాష్బోర్డ్ ఎండ్పాయింట్లు స్థితి/ఆడిట్ డేటాను చదివి, HTTP రవాణాలను ప్రాక్సీ చేస్తాయి.

విధానం	మార్గం	వివరణ
GET	`/api/mcp/status`	హార్ట్బీట్, రవాణా, ఆన్లైన్ స్థితి, చివరి కాల్, అగ్ర సాధనాలు, 24గం విజయ శాతం
GET	`/api/mcp/tools`	`name`, `description`, `scopes`, `phase`, `auditLevel`, `sourceEndpoints`తో కూడిన MCP సాధనాల జాబితా
GET	`/api/mcp/sse`	SSE రవాణా కోసం SSE స్ట్రీమ్ను తెరుస్తుంది (MCP నిలిపివేయబడి ఉంటే లేదా రవాణా సరిపోలకపోతే `503`ను తిరిగి ఇస్తుంది)
POST	`/api/mcp/sse`	SSE రవాణాపై JSON-RPC ఫ్రేమ్ను పంపుతుంది
GET	`/api/mcp/stream`	Streamable HTTP రవాణా యొక్క SSE వైపును తెరుస్తుంది (సర్వర్ ప్రారంభించిన సందేశాలు)
POST	`/api/mcp/stream`	Streamable HTTP రవాణాపై JSON-RPC ఫ్రేమ్ను పంపుతుంది
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 తనిఖీ/డ్యాష్బోర్డ్ వినియోగం కోసం REST ర్యాపర్తో పాటు A2A (Agent-to-Agent) JSON-RPC 2.0 ఎండ్పాయింట్ను అందిస్తుంది.

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": "ఈ కోడింగ్ టాస్క్ను రూట్ చేయండి"}]
  }
}

మద్దతు ఉన్న మెథడ్లు (అన్నీ 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`	స్థానిక రూటింగ్ పట్టికను ఉపయోగించి లాజికల్ మోడల్ idని నిర్దిష్ట ప్రొవైడర్/మోడల్గా పరిష్కరిస్తుంది
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 కుకీ) లేదా నిర్వహణ-స్కోప్ గల API కీ అవసరం.

పూర్తి వివరాల కోసం ACP ఫ్రేమ్వర్క్ చూడండి.

విశ్లేషణలు & పరిశీలనీయత

రూటింగ్, కంప్రెషన్ మరియు ప్రొవైడర్ వైవిధ్యాన్ని పర్యవేక్షించడానికి రియల్-టైమ్ విశ్లేషణ ఎండ్పాయింట్లు. ఇవి /dashboard/analytics/* పేజీలకు శక్తినిస్తాయి.

ఆటో-రూటింగ్ విశ్లేషణలు

పద్ధతి	పాత్	వివరణ
GET	`/api/analytics/auto-routing`	సమగ్ర ఆటో-రూటింగ్ గణాంకాలు: మొత్తం కాల్లు, వ్యూహ పంపిణీ, టైర్ పంపిణీ, అగ్ర ప్రొవైడర్లు
GET	`/api/analytics/auto-routing?days=7`	సమయ-పరిధి గణాంకాలు (డిఫాల్ట్గా 24h)

ప్రతిస్పందన ఉదాహరణ:

{
  "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": ["ట్రాఫిక్లో 40% OpenAI ఖాతాలో ఉంది — వైవిధ్యీకరణను పరిగణించండి"]
}

ప్రామాణీకరణ: నిర్వహణ సెషన్ లేదా నిర్వహణ-స్కోప్ గల API కీ అవసరం.

అడ్మిన్ కార్యకలాపాలు

కార్యాచరణ నిర్వహణ కోసం అడ్మిన్లకు మాత్రమే అందుబాటులో ఉండే ఎండ్పాయింట్లు.

పద్ధతి	మార్గం	వివరణ
GET	`/api/admin/concurrency`	ప్రస్తుత సమకాలీనత పరిమితులను చదవండి (గ్లోబల్ + ఒక్కో ప్రొవైడర్కు)
POST	`/api/admin/concurrency`	సమకాలీనత పరిమితులను నవీకరించండి — బాడీ: `{global?: number, perProvider?: Record<string, number>}`

ప్రమాణీకరణ: అడ్మిన్ స్కోప్తో కూడిన నిర్వహణ సెషన్ అవసరం.

CLI సాధనాల నిర్వహణ

OmniRouteతో అనుసంధానమయ్యే CLI సాధనాలను (antigravity, chipotle, 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`; లెగసీ Codex YAMLను `migration` సూచిస్తుంది)
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 అలియాస్లను కాన్ఫిగర్ చేయండి

ప్రమాణీకరణ: నిర్వహణ సెషన్ అవసరం.

ఏజెంట్ నైపుణ్యాలు

AI ఏజెంట్ నైపుణ్యాలను నిర్వహించండి (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`	సహజ భాషా వివరణ ఆధారంగా AIతో కొత్త నైపుణ్యాన్ని రూపొందించండి

ప్రమాణీకరణ: నిర్వహణ సెషన్ లేదా నిర్వహణ-స్కోప్ గల 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 కీ అవసరం.

వెబ్హుక్లు

ఈవెంట్ల కోసం వెబ్హుక్ సబ్స్క్రిప్షన్లను నిర్వహించండి.

పద్ధతి	పాత్	వివరణ
GET	`/api/webhooks`	అన్ని వెబ్హుక్ సబ్స్క్రిప్షన్లను జాబితా చేయండి
POST	`/api/webhooks`	వెబ్హుక్ సబ్స్క్రిప్షన్ను సృష్టించండి — బాడీ: `{url, events[], secret?, active?}`
GET	`/api/webhooks/[id]`	నిర్దిష్ట వెబ్హుక్ సబ్స్క్రిప్షన్ను పొందండి
PUT	`/api/webhooks/[id]`	వెబ్హుక్ సబ్స్క్రిప్షన్ను నవీకరించండి
DELETE	`/api/webhooks/[id]`	వెబ్హుక్ సబ్స్క్రిప్షన్ను తొలగించండి
GET	`/api/webhooks/[id]/deliveries`	వెబ్హుక్ డెలివరీ చరిత్రను జాబితా చేయండి (విజయం/వైఫల్యం లాగ్)
POST	`/api/webhooks/[id]/test`	వెబ్హుక్కు పరీక్ష ఈవెంట్ను పంపండి

ప్రామాణీకరణ: నిర్వహణ సెషన్ అవసరం.

పూర్తి ఈవెంట్ రకాల కోసం వెబ్హుక్స్ ఫ్రేమ్వర్క్ చూడండి.

స్కిల్స్ ఫ్రేమ్వర్క్

స్కిల్స్ను (ఏజెంటిక్ ఎక్స్టెన్షన్స్ ఫ్రేమ్వర్క్) నిర్వహించండి.

పద్ధతి	పాత్	వివరణ
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 కుకీని ఉపయోగిస్తాయి
లాగిన్ సేవ్ చేసిన పాస్వర్డ్ హాష్ను ఉపయోగిస్తుంది; అది అందుబాటులో లేకపోతే INITIAL_PASSWORDను ఉపయోగిస్తుంది
requireLoginను /api/settings/require-login ద్వారా టాగుల్ చేయవచ్చు
REQUIRE_API_KEY=true అయినప్పుడు /v1/* రూట్లకు ఐచ్ఛికంగా బేరర్ API కీ అవసరం
ఈ రెఫరెన్స్లో "నిర్వహణ టోకెన్" / "నిర్వహణ-పరిధి API కీ" అంటే ఆ గైడ్లోని కుటుంబాలలో ఒకటి — నిర్వచించని అదనపు రహస్య రకం కాదు

బ్రేకింగ్ మార్పు (v3.8.0) — /api/v1/agents/tasks/* మరియు కూల్డౌన్ నిర్వహణ ఎండ్పాయింట్లకు ఇప్పుడు నిర్వహణ ప్రమాణీకరణ (డ్యాష్బోర్డ్ auth_token కుకీ లేదా నిర్వహణ-పరిధి API కీ) అవసరం. గతంలో ఈ రూట్లను ప్రమాణీకరణ లేకుండా కాల్ చేసిన క్లయింట్లు 401 Unauthorizedను అందుకుంటాయి. కమిట్ 588a0333 (fix(auth): require management auth for agent and cooldown APIs) చూడండి.

192 KiB Raw Blame History Unescape Escape

API Reference (తెలుగు)

విషయ సూచిక

చాట్ పూర్తీకరణలు

అనుకూల హెడర్లు

ప్రత్యేక నిర్వహిత సెషన్ లీజులు

x-omniroute-compression

ఎంబెడ్డింగ్లు

చిత్ర సృష్టి

డాక్యుమెంట్ OCR

Azure Document Intelligence పోల్ ప్రవాహం

Vertex AI DeepSeek OCR ప్రామాణీకరణ మరియు ఎండ్పాయింట్ పరిష్కారం

మోడళ్ల జాబితా

మోడల్ id ప్రిఫిక్స్లు (?prefix=)

ఆలోచన-రహిత మోడల్ వేరియంట్లు

ప్రొవైడర్ ప్లగిన్ మానిఫెస్ట్

అనుకూలత ఎండ్పాయింట్లు

ప్రత్యేక ప్రొవైడర్ రూట్లు

Files API

Batches API

Search API

Web Fetch API

WebSocket స్ట్రీమింగ్

WebSocket ద్వారా Responses API (codex మాత్రమే)

మోడల్ id: సాధారణ ChatGPT idను ఉపయోగించండి (codex/ ప్రిఫిక్స్ లేకుండా)

OpenAI Codex CLIని కాన్ఫిగర్ చేయడం

కోటాలు & సమస్యల నివేదన

స్వీయ-సేవ వినియోగం (/api/usage/om-usage)

సెమాంటిక్ క్యాష్

లేటెన్సీ ప్రభావం

ప్రతి-కీ క్యాష్ బైపాస్

ప్రతి-అభ్యర్థన బైపాస్

డ్యాష్బోర్డ్ & నిర్వహణ

ప్రమాణీకరణ

ప్రొవైడర్ నిర్వహణ

OAuth ప్రవాహాలు

రూటింగ్ & కాన్ఫిగ్

వినియోగం & విశ్లేషణలు

సెట్టింగ్లు

కాంటెక్స్ట్ & కంప్రెషన్

పర్యవేక్షణ

బ్యాకప్ & ఎగుమతి/దిగుమతి

క్లౌడ్ సమకాలీకరణ

టన్నెల్లు

CLI సాధనాలు

ACP ఏజెంట్లు

స్థితిస్థాపకత & రేట్ పరిమితులు

మూల్యాంకనాలు

విధానాలు

అనుపాలన

v1beta (Gemini-అనుకూలం)

అంతర్గత / సిస్టమ్ APIలు

OAuth ఎన్విరాన్మెంట్ మరమ్మతు (v3.6.1+)

ఆడియో ట్రాన్స్క్రిప్షన్

Ollama అనుకూలత

టోకెన్తో కూడిన VS Code / హెడర్లెస్ అలియాస్లు

టెలిమెట్రీ

బడ్జెట్

టోకెన్ పరిమితులు

అభ్యర్థన ప్రాసెసింగ్

కాంబో నిర్వహణ

వెబ్హుక్స్

నమోదిత కీలు (స్వయంచాలక నిర్వహణ)

ఏజెంట్ల ప్రోటోకాల్

మేనేజ్మెంట్ ప్రాక్సీలు

స్థితిస్థాపకత (విస్తృతం)

నైపుణ్యాలు

మెమరీ

MCP సర్వర్

A2A సర్వర్

JSON-RPC

ఏజెంట్ కార్డ్

REST సహాయకాలు

క్లౌడ్, మూల్యాంకనాలు & అంచనా

ACP (Agent Client Protocol) నిర్వహణ

విశ్లేషణలు & పరిశీలనీయత

ఆటో-రూటింగ్ విశ్లేషణలు

కంప్రెషన్ విశ్లేషణలు

ప్రొవైడర్ వైవిధ్య ట్రాకింగ్

అడ్మిన్ కార్యకలాపాలు

192 KiB

Raw Blame History

`x-omniroute-compression`

మోడల్ id ప్రిఫిక్స్లు (`?prefix=`)

మోడల్ id: సాధారణ ChatGPT idను ఉపయోగించండి (`codex/` ప్రిఫిక్స్ లేకుండా)

స్వీయ-సేవ వినియోగం (`/api/usage/om-usage`)