चैट पूर्णता

प्रमाणीकरण

प्रत्येक अनुरोध के लिए बियरर टोकन (आपकी Airforce एपीआई कुंजी) की आवश्यकता होती है। Anthropic x-api-key हेडर भी स्वीकार किया जाता है /v1/messages एसडीके अनुकूलता के लिए.

Authorization: Bearer sk-air-YOUR_API_KEY
# alt for /v1/messages:
x-api-key: sk-air-YOUR_API_KEY

POST /v1/chat/completions

OpenAI-संगत चैट पूर्णताएँ। अधिकारी के साथ काम करता है openai ओवरराइड करके SDK base_url को https://api.airforce/v1.

निकाय से अनुरोध करें

मूल उदाहरण

curl https://api.airforce/v1/chat/completions \
  -H "Authorization: Bearer sk-air-YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.1-chat",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "What is the capital of France?"}
    ],
    "max_tokens": 200,
    "temperature": 0.7
  }'

प्रतिक्रिया स्वरूप

{
  "id": "chatcmpl-abc123",
  "object": "chat.completion",
  "created": 1710000000,
  "model": "gpt-5.1-chat",
  "choices": [{
    "index": 0,
    "message": {
      "role": "assistant",
      "content": "The capital of France is Paris."
    },
    "finish_reason": "stop"
  }],
  "usage": {
    "prompt_tokens": 20,
    "completion_tokens": 8,
    "total_tokens": 28
  }
}

तर्क और सोच

Reasoning/thinking is a cross-model feature for every model ID with supports_reasoning: true — Claude, OpenAI o-series/GPT-5, Gemini, Qwen, DeepSeek, and others. You send the same canonical parameters; Airforce maps them to each provider's native shape. This is not a DeepSeek-only API.

Truth source: check supports_reasoning: true में एक मॉडल पर GET /v1/models (or GET /api/models/{id}/allowed-params). Prefer that flag over guessing from the model name.

विहित पैरामीटर

What differs by family (mapping only)

Parameters are the same everywhere. Only how we map them (and how hard "off" is) differs:

• Claude — Thinking on/off + budget; often also reasoning_effort via the gateway.
• OpenAI (o1/o3, GPT-5) — Mainly reasoning_effort. A full "thinking off" is often not available — you control how strongly the model reasons, not always whether it reasons at all.
• Gemini — thinking_config / budget mapped internally.
• Qwen / Xiaomi / Alibaba — thinking + enable_thinking-style controls.
• DeepSeek (generic) — Hybrid on/off is especially clear: thinking: { type: enabled|disabled } plus optional reasoning_effort.
• Resellers / other — Often generic passthrough of the same canonical fields.

Controlling where the trace appears

An optional reasoning object on the request decides what happens to the thinking trace. It is consumed by Airforce and never forwarded upstream.

"reasoning": { "format": "separate", "exclude": false }

तर्क प्रयास (OpenAI-शैली)

Primary control for o-series and GPT-5: how much the model may reason. Same canonical field as on every other supports_reasoning model — OpenAI is included, but behaviour is not 1:1 with DeepSeek's hard on/off.

curl https://api.airforce/v1/chat/completions \
  -H "Authorization: Bearer sk-air-YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "o3-mini",
    "messages": [{"role": "user", "content": "Prove the Pythagorean theorem."}],
    "reasoning_effort": "high"
  }'

विस्तारित सोच (Anthropic-शैली)

Budget-based thinking for Claude (and gateways that accept the Anthropic shape). You can still send reasoning_effort; we map when the channel supports it.

curl https://api.airforce/v1/chat/completions \
  -H "Authorization: Bearer sk-air-YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4.6",
    "messages": [{"role": "user", "content": "Plan a 7-day Italy trip."}],
    "thinking": {"type": "enabled", "budget_tokens": 4000}
  }'

Hybrid thinking (e.g. DeepSeek V3.2/V4)

Example of a hybrid model family with a clear Thinking / Non-Thinking switch — not a separate protocol. deepseek-v3.2, deepseek-v4-flash and deepseek-v4-pro accept the same canonical fields as every other supports_reasoning model. Toggle thinking and optionally set effort in one request:

curl https://api.airforce/v1/chat/completions \
  -H "Authorization: Bearer sk-air-YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-pro",
    "messages": [{"role": "user", "content": "Solve this step by step: integrate x^2 * e^x."}],
    "thinking": {"type": "enabled"},
    "reasoning_effort": "high"
  }'

Turn thinking off (faster, cheaper when you only need the final answer) — this hard off is clearer on hybrid models than on many OpenAI o-series profiles:

"thinking": {"type": "disabled"}
// or simply: "thinking": "off"

Native docs for this family often list effort levels such as "high" and "max". We accept the full low…max scale and map unsupported levels to the nearest value that reaches the model. Prefer the hybrid IDs above over retired deepseek-chat / deepseek-reasoner names when you need an explicit on/off switch.

तर्क का निशान स्वयं प्रकट होता है choices[0].message.reasoning (OpenAI आकार) या जैसे thinking में ब्लॉक करता है content (Anthropic आकृति)। रीज़निंग टोकन को बिल किया जाता है और रिपोर्ट किया जाता है usage.completion_tokens_details.reasoning_tokens.

वह completion_tokens_details.reasoning_tokens विवरण केवल तभी मौजूद होता है जब अपस्ट्रीम प्रोवाइडर इसे रिपोर्ट करता है। एक streamed रिस्पॉन्स पर ट्रेस प्रति chunk delta.reasoning_content पर आता है।

दृष्टि एवं छवि इनपुट

के साथ मॉडल supports_vision: true सामग्री ब्लॉक के रूप में एम्बेड की गई छवियों को स्वीकार करें। या तो एक सार्वजनिक यूआरएल या बेस64 डेटा यूआरएल काम करता है; आकार सीमाएँ अपस्ट्रीम मॉडल पर निर्भर करती हैं।

curl https://api.airforce/v1/chat/completions \
  -H "Authorization: Bearer sk-air-YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.1-chat",
    "messages": [{
      "role": "user",
      "content": [
        {"type": "text", "text": "What is in this image?"},
        {"type": "image_url", "image_url": {"url": "https://example.com/cat.jpg"}}
      ]
    }]
  }'

टूल कॉलिंग

के साथ मॉडल supports_tools: true आपके द्वारा परिभाषित फ़ंक्शंस को कॉल कर सकते हैं। मॉडल एक लौटाता है tool_calls सारणी; आप कॉल चलाएं, फिर परिणाम वापस भेजें tool संदेश।

अनुरोध

curl https://api.airforce/v1/chat/completions \
  -H "Authorization: Bearer sk-air-YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.1-chat",
    "messages": [{"role": "user", "content": "What is the weather in Paris?"}],
    "tools": [{
      "type": "function",
      "function": {
        "name": "get_weather",
        "description": "Get current weather for a location",
        "parameters": {
          "type": "object",
          "properties": {
            "location": {"type": "string", "description": "City name"}
          },
          "required": ["location"]
        }
      }
    }],
    "tool_choice": "auto"
  }'

टूल कॉल के साथ प्रतिक्रिया

{
  "id": "chatcmpl-abc123",
  "choices": [{
    "index": 0,
    "message": {
      "role": "assistant",
      "content": null,
      "tool_calls": [{
        "id": "call_1",
        "type": "function",
        "function": {
          "name": "get_weather",
          "arguments": "{\"location\":\"Paris\"}"
        }
      }]
    },
    "finish_reason": "tool_calls"
  }]
}

टूल परिणाम के साथ अनुवर्ती कार्रवाई करें

{
  "model": "gpt-5.1-chat",
  "messages": [
    {"role": "user", "content": "What is the weather in Paris?"},
    {
      "role": "assistant",
      "content": null,
      "tool_calls": [{
        "id": "call_1",
        "type": "function",
        "function": {"name": "get_weather", "arguments": "{\"location\":\"Paris\"}"}
      }]
    },
    {"role": "tool", "tool_call_id": "call_1", "content": "{\"temp_c\": 14, \"sky\": \"cloudy\"}"}
  ]
}

Assistant prefill

End your messages array with an assistant message that already contains some text, and the model continues from it instead of starting a fresh turn. This is a reliable way to force a response to begin a specific way — a leading "{" for JSON, a chosen language, or a fixed prefix. The same trick works on /v1/messages. Providers that reject native prefill are handled automatically: the gateway retries once with a compatible rewrite, so you do not have to special-case them.

{
  "model": "claude-sonnet-4.6",
  "messages": [
    {"role": "user", "content": "List three primary colors as a JSON array."},
    {"role": "assistant", "content": "["}
  ]
}

Structured outputs

Set response_format to make the model return JSON. Two modes are supported:

• { "type": "json_object" } — the response is a single valid JSON value.
• { "type": "json_schema", "json_schema": { "name", "schema", "strict" } } — the model is steered to produce JSON that matches your JSON Schema.

curl https://api.airforce/v1/chat/completions \
  -H "Authorization: Bearer sk-air-YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.1-chat",
    "messages": [{"role": "user", "content": "Extract the city and country: I live in Paris, France."}],
    "response_format": {
      "type": "json_schema",
      "json_schema": {
        "name": "location",
        "schema": {
          "type": "object",
          "properties": { "city": {"type": "string"}, "country": {"type": "string"} },
          "required": ["city", "country"]
        }
      }
    }
  }'

Reliability: even when a model wraps its answer in prose or a markdown code fence, Airforce extracts the JSON payload so you always receive parseable content. If no valid JSON can be recovered, the original text is returned unchanged — so the guarantee never makes a response worse. This applies to non-streamed responses; streamed responses are passed through unchanged.

स्ट्रीमिंग

तय करना stream: true सर्वर-भेजे गए ईवेंट के रूप में आंशिक पूर्णताएँ प्राप्त करने के लिए। प्रत्येक घटना एक JSON खंड है जिसका आकार गैर-स्ट्रीम प्रतिक्रिया के समान है, सिवाय इसके message द्वारा प्रतिस्थापित किया जाता है delta. धारा समाप्त होती है data: [DONE].

curl https://api.airforce/v1/chat/completions \
  -H "Authorization: Bearer sk-air-YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.1-chat",
    "messages": [{"role": "user", "content": "Write a haiku about Berlin."}],
    "stream": true,
    "stream_options": {"include_usage": true}
  }'

तार प्रारूप

data: {"id":"chatcmpl-abc123","object":"chat.completion.chunk","created":1710000000,"model":"gpt-5.1-chat","choices":[{"index":0,"delta":{"role":"assistant"},"finish_reason":null}]}

data: {"id":"chatcmpl-abc123","object":"chat.completion.chunk","created":1710000000,"model":"gpt-5.1-chat","choices":[{"index":0,"delta":{"content":"Cold "},"finish_reason":null}]}

data: {"id":"chatcmpl-abc123","object":"chat.completion.chunk","created":1710000000,"model":"gpt-5.1-chat","choices":[{"index":0,"delta":{"content":"stone "},"finish_reason":null}]}

…

data: {"id":"chatcmpl-abc123","object":"chat.completion.chunk","created":1710000000,"model":"gpt-5.1-chat","choices":[{"index":0,"delta":{},"finish_reason":"stop"}],"usage":{"prompt_tokens":12,"completion_tokens":17,"total_tokens":29}}

data: [DONE]

Reliability & smart routing

Every model ID resolves to a pool of upstream providers behind the scenes. If the first one errors or times out, the request is automatically retried against the next provider for the same model, in order, before any failure is returned — you do not configure or trigger this. The model field in the response always reports the variant that actually answered. This is independent of the optional models / fallbacks array, which adds your own cross-model candidates on top: first the primary model exhausts its own provider chain, then each fallback model exhausts its chain.

POST /v1/messages

Anthropic-संगत संदेश एपीआई। अधिकारी के साथ काम करता है @anthropic-ai/sdk सेटिंग द्वारा baseURL को https://api.airforce. OpenAI/Google/आदि को अग्रेषित करें। गैर-क्लाउड मॉडल के लिए पारदर्शी रूप से।

निकाय से अनुरोध करें

उदाहरण

curl https://api.airforce/v1/messages \
  -H "x-api-key: sk-air-YOUR_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4.6",
    "max_tokens": 256,
    "system": "You are a helpful assistant.",
    "messages": [
      {"role": "user", "content": "Hello, Claude!"}
    ]
  }'

प्रतिक्रिया स्वरूप

स्ट्रीमिंग इवेंट

Anthropic SSE एकबारगी JSON खंडों के बजाय नामित घटनाओं का उपयोग करता है। प्रत्येक घटना में दोनों होते हैं event: नाम और ए data: JSON पेलोड.

event: message_start
data: {"type":"message_start","message":{"id":"msg_01","role":"assistant","content":[],"model":"claude-sonnet-4.6","stop_reason":null,"usage":{"input_tokens":12,"output_tokens":1}}}

event: content_block_start
data: {"type":"content_block_start","index":0,"content_block":{"type":"text","text":""}}

event: content_block_delta
data: {"type":"content_block_delta","index":0,"delta":{"type":"text_delta","text":"Hello"}}

event: content_block_stop
data: {"type":"content_block_stop","index":0}

event: message_delta
data: {"type":"message_delta","delta":{"stop_reason":"end_turn"},"usage":{"output_tokens":17}}

event: message_stop
data: {"type":"message_stop"}

POST /v1/messages/count_tokens

Anthropic-compatible token counting. Send the same system / messages / tools you would pass to /v1/messages and get an input-token estimate back without running the model — nothing is billed.

curl https://api.airforce/v1/messages/count_tokens \
  -H "x-api-key: sk-air-YOUR_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4.6",
    "system": "You are a helpful assistant.",
    "messages": [{"role": "user", "content": "Hello, Claude!"}]
  }'

# → {"input_tokens": 34}

The count is a fast character-based estimate (about 4 characters per token) over system, messages and tools — close enough for context-budget checks, not an exact tokenizer run.

शीघ्र कैशिंग

पर /v1/messages क्लाउड मॉडल के साथ, एक उपसर्ग को पास करके कैश्ड के रूप में चिह्नित करें system ब्लॉकों की एक सरणी के रूप में जहां कैश्ड सेगमेंट चलता है cache_control: { type: "ephemeral" }. बाद के अनुरोध जो समान उपसर्ग से शुरू होते हैं, सस्ती कैश-रीड दर चार्ज करते हैं। के साथ मॉडल supports_caching: true में /v1/models इसका समर्थन करें.

{
  "model": "claude-sonnet-4.6",
  "max_tokens": 1024,
  "system": [
    {"type": "text", "text": "You are a senior staff engineer at Airforce."},
    {
      "type": "text",
      "text": "<repository-snapshot>...</repository-snapshot>",
      "cache_control": {"type": "ephemeral"}
    }
  ],
  "messages": [
    {"role": "user", "content": "Where is rate limiting enforced?"}
  ]
}

रिस्पॉन्स में कैश काउंट कैसे रिपोर्ट किए जाते हैं

कैश टोकन काउंट प्रत्येक फॉर्मेट के मूल आकार में पास किए जाते हैं, इसलिए SDK (openai, @anthropic-ai/sdk, @google/genai) उन्हें कस्टम कोड के बिना पढ़ते हैं। जब मान शून्य होता है तो फ़ील्ड छोड़ दिए जाते हैं, जिससे गैर-कैश्ड रिस्पॉन्स हल्के रहते हैं।

/v1/chat/completions (OpenAI आकार)

"usage": {
  "prompt_tokens": 2104,
  "completion_tokens": 147,
  "total_tokens": 2251,
  "prompt_tokens_details": { "cached_tokens": 1980 },
  "cache_creation_input_tokens": 124,
  "cache_creation": {
    "ephemeral_5m_input_tokens": 124,
    "ephemeral_1h_input_tokens": 0
  }
}

/v1/messages (Anthropic आकार)

"usage": {
  "input_tokens": 2104,
  "output_tokens": 147,
  "cache_read_input_tokens": 1980,
  "cache_creation_input_tokens": 124,
  "cache_creation": {
    "ephemeral_5m_input_tokens": 124,
    "ephemeral_1h_input_tokens": 0
  }
}

/v1beta/.../generateContent (Gemini आकार)

"usageMetadata": {
  "promptTokenCount": 2104,
  "candidatesTokenCount": 147,
  "totalTokenCount": 2251,
  "cachedContentTokenCount": 1980
}

कैशिंग कहाँ लागू होती है

Claude मॉडलों के लिए स्पष्ट cache_control मार्कर /v1/messages और /v1/chat/completions दोनों पर मान्य हैं — उन्हें system या message कंटेंट ब्लॉक पर लगाएँ। कई अन्य प्रोवाइडर (OpenAI-परिवार, DeepSeek, Gemini) स्वतः कैश करते हैं: आप कोई मार्कर नहीं भेजते और जैसे ही पर्याप्त लंबा प्रीफ़िक्स दोबारा उपयोग होता है, प्रतिक्रिया में cached_tokens दिख जाता है।

कैश अवधि: 5 मिनट या 1 घंटा

कैश किया गया प्रीफ़िक्स डिफ़ॉल्ट रूप से 5 मिनट जीवित रहता है और हर हिट पर टाइमर रिफ़्रेश होता है। अधिक समय तक रहने वाले प्रीफ़िक्स के लिए मार्कर में ttl: "1h" जोड़ें। प्रतिक्रिया प्रत्येक TTL को cache_creation के अंतर्गत अलग-अलग रिपोर्ट करती है।

"cache_control": { "type": "ephemeral", "ttl": "1h" }

उदाहरण: पहले write, फिर read

बिल्कुल वही अनुरोध दो बार भेजें (ऊपर का कैशिंग उदाहरण)। प्रीफ़िक्स को पहली बार देखने वाला कॉल एक बार का cache write चुकाता है; TTL के भीतर समान कॉल बहुत सस्ता cache read चुकाते हैं।

पहला कॉल — cache write (usage अंश):

"usage": {
  "input_tokens": 2104,
  "output_tokens": 12,
  "cache_creation_input_tokens": 1980,
  "cache_read_input_tokens": 0
}

TTL के भीतर दूसरा समान कॉल — cache read:

"usage": {
  "input_tokens": 2104,
  "output_tokens": 12,
  "cache_creation_input_tokens": 0,
  "cache_read_input_tokens": 1980
}

सीमाएँ और लागत

• Claude को न्यूनतम कैश-योग्य प्रीफ़िक्स चाहिए (लगभग 1024 टोकन; कुछ मॉडलों के लिए अधिक)। इससे छोटे प्रीफ़िक्स कैश ही नहीं होते।
• प्रति अनुरोध अधिकतम 4 cache breakpoints, और कैश किया गया प्रीफ़िक्स कॉल के बीच बाइट-दर-बाइट समान होना चाहिए — एक अक्षर का बदलाव भी कैश चूक जाता है।
• Cache writes सामान्य इनपुट से महँगे होते हैं (5m ≈ 1.25×, 1h ≈ 2×); reads बहुत सस्ते (≈ 0.1×)। प्रत्येक मॉडल की कैश कीमतें प्राइसिंग पेज पर देखें।

POST /v1/responses

स्टेटफुल बातचीत के लिए OpenAI Responses-API सतह। समान Bearer/x-api-key प्रमाणीकरण। कैश गणना input_tokens_details.cached_tokens (रीड) प्लस फ्लैट cache_creation_input_tokens + cache_creation.ephemeral_* (राइट्स) के रूप में दिखाई देती है, /v1/chat/completions के साथ समानता के लिए।

POST /v1beta/models/{model}:generateContent

Google Gemini-compatible endpoint. Works with the official @google/genai SDK and the Gemini CLI by pointing the base URL at https://api.airforce/v1beta. Any routed model works — requests are translated to and from the native Gemini shape, and the model is taken from the URL path (not the body).

Authentication

Pass your Airforce API key any of the three ways Google clients use:

# 1) query parameter (Google default)
?key=sk-air-YOUR_API_KEY

# 2) header
x-goog-api-key: sk-air-YOUR_API_KEY

# 3) bearer token
Authorization: Bearer sk-air-YOUR_API_KEY

Request body

Example

curl "https://api.airforce/v1beta/models/gemini-3.1-pro:generateContent" \
  -H "x-goog-api-key: sk-air-YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contents": [
      {"role": "user", "parts": [{"text": "What is the capital of France?"}]}
    ],
    "systemInstruction": {"parts": [{"text": "You are a helpful assistant."}]},
    "generationConfig": {"temperature": 0.7, "maxOutputTokens": 256}
  }'

Response shape

{
  "candidates": [{
    "content": {
      "role": "model",
      "parts": [{"text": "The capital of France is Paris."}]
    },
    "finishReason": "STOP",
    "index": 0
  }],
  "usageMetadata": {
    "promptTokenCount": 16,
    "candidatesTokenCount": 8,
    "totalTokenCount": 24
  },
  "modelVersion": "gemini-3.1-pro"
}

POST /v1beta/models/{model}:streamGenerateContent

Streaming uses the :streamGenerateContent action and returns Server-Sent Events. Each data: line is a full Gemini-shaped chunk (not a delta object); the final chunk carries usageMetadata.

data: {"candidates":[{"content":{"role":"model","parts":[{"text":"The capital"}]},"index":0}],"modelVersion":"gemini-3.1-pro"}

data: {"candidates":[{"content":{"role":"model","parts":[{"text":" is Paris."}]},"index":0}],"modelVersion":"gemini-3.1-pro"}

data: {"candidates":[{"content":{"role":"model","parts":[]},"finishReason":"STOP","index":0}],"usageMetadata":{"promptTokenCount":16,"candidatesTokenCount":8,"totalTokenCount":24}}

List models

The catalog is also exposed in Gemini Model-resource shape so Google clients can enumerate models.

curl https://api.airforce/v1beta/models

Notes: the base URL is https://api.airforce/v1beta (or /v1), not Google's host. The model name comes from the URL path, not the request body. Only the first candidate is returned, and a subset of Gemini fields is translated — safetySettings and cachedContent are currently ignored. Billing, rate limits and smart routing apply exactly as on /v1/chat/completions.

त्रुटियाँ

Airforce मानक HTTP स्थिति कोड और दोनों समापन बिंदुओं के लिए एक समान त्रुटि लिफाफा लौटाता है।

{
  "error": {
    "message": "The requested model does not exist or you do not have access to it.",
    "type": "model_not_found",
    "param": null,
    "code": "404"
  }
}

वर्णनात्मक स्लग type में होता है। code स्ट्रिंग के रूप में HTTP स्टेटस है (जैसे "404"), और param पैरामीटर-रेंज वैलिडेशन त्रुटियों को छोड़कर null होता है, जहाँ यह आपत्तिजनक पैरामीटर का नाम बताता है।

curl https://api.airforce/v1/models \
  -H "Authorization: Bearer sk-air-YOUR_API_KEY"