Compatibility Guide

OpenAI Model Compatibility

DEVUP AI serves OpenAI models on the Chat Completions endpoint. Existing OpenAI SDK code connects with a base URL change. OpenAI models validate parameters strictly and do not take some sampling settings that other models accept.

Important: sampling parameters are not applied on OpenAI models

Settings such as temperature (other than 1), top_p, and stop are not supported by these models. The request is answered without them, and each one is listed as a notice in the response metadata.

1. How to call these models

This guide applies to the following models on /v1/chat/completions: openai/gpt-6-astra, openai/gpt-5.6-sol, openai/gpt-5.6-terra, openai/gpt-5.6-luna, openai/gpt-5.5, openai/gpt-5.4, openai/gpt-5.4-mini, and openai/gpt-5.4-nano. For models supported on the Responses endpoint, see the Responses API documentation.

Use the model identifier verbatim as catalogued in DEVUP AI (e.g. openai/gpt-5.6-luna). Configure your OpenAI client with our unified base URL https://api.devupai.com/v1 and your DEVUP AI API key.

import os
from openai import OpenAI

# Initialize the client with the DEVUP AI base URL
client = OpenAI(
    api_key=os.environ["DEVUP_API_KEY"],
    base_url="https://api.devupai.com/v1",
)

# Use the catalog identifier verbatim
response = client.chat.completions.create(
    model="openai/gpt-5.6-luna",
    messages=[
        {"role": "user", "content": "Explain the concept of entropy in one concise paragraph."}
    ],
    max_tokens=200,
)

print(response.choices[0].message.content)
print(f"Tokens: {response.usage.prompt_tokens} prompt, {response.usage.completion_tokens} completion")

2. Parameter support

Requests forwarded to OpenAI destinations are validated against an allowlist. For general request structure and standard parameter definitions, see the Chat Completions documentation. Every parameter falls into exactly one of three categories:

Parameter	Behaviour	Note
model	supported	Resolved to the selected model's identifier.
messages	supported	Standard conversation messages array.
stream	supported	Server-Sent Events streaming is supported. Every stream ends with one chunk whose `choices` is empty and which carries a `usage` object with real token counts, just before `data: [DONE]`. No other chunk carries `usage`.
max_tokens	translated	Automatically translated to `max_completion_tokens`. If both are sent, `max_completion_tokens` is preferred and `max_tokens` is not applied, with a notice.
max_completion_tokens	supported	Native completion token ceiling accepted directly.
frequency_penalty	supported	Passed to the model without modification.
presence_penalty	supported	Passed to the model without modification.
n	supported	Number of completion choices to generate.
seed	supported	Deterministic sampling seed.
user	supported	End-user identifier for telemetry and abuse tracking.
logprobs	supported	Token log probability calculation.
response_format	supported	Structured outputs (e.g. JSON object or JSON Schema). On a model that returns JSON inside a Markdown code fence, the fence around the whole reply is removed (notice `json_fence_removed`). On a model that does not apply json_schema but enforces tool calls, a json_schema request without streaming is answered through a forced tool call (notice `structured_output_via_tool`).
tools	supported	Function definitions for tool calling.
tool_choice	supported	Accepts `none`, `auto`, `required` and a named function. `required` or a named function without `tools` returns HTTP 400 with code `missing_tools`; `none` and `auto` without `tools` are accepted.
reasoning_effort	supported	Controls reasoning token budget. Accepted values are `none`, `low`, `medium`, `high`, and `xhigh` (`max` is not accepted; `openai/gpt-6-astra` rejects `none`). Generated reasoning tokens count toward the completion token budget.
reasoning	rewritten	`{"enabled": true}` is applied as `reasoning_effort: "medium"`, with a notice in `_devup.warnings`. When the request also sets `reasoning_effort`, that value applies, with a notice. `{"enabled": false}` does not turn reasoning off: the model reasons at its default level, with a notice; use `reasoning_effort` to set the reasoning. On a model that does not accept `reasoning_effort`, `reasoning` is not applied, with a notice.
temperature	not applied	Only the default value of `1` is accepted. Any other value is not applied, with a notice, rather than rejected.
top_p	not applied	Not taken by these models. Left out, with a notice.
stop	not applied	Not taken by these models. Left out, with a notice.
parallel_tool_calls	not applied	Copied only when `tools` is present and non-empty. Otherwise left out, with a notice.
usage	not applied	Not taken by these models. Left out, with a notice.
Any unlisted parameter	not applied	Strict allowlist. Any parameter not listed above (e.g. `logit_bias`, `metadata`) is left out, with a notice naming the field.

3. Why not applied rather than rejected

Rejecting requests that contain parameters like temperature or top_p with an HTTP 400 error would break standard OpenAI-compatible SDKs, which attach default sampling parameters automatically. Instead, the request is answered without those fields, and each one is listed as a notice in the response metadata, so existing client code keeps working.

4. How to see what was dropped

Successful non-streaming responses include a _devup metadata object when billing metadata is available. When unsupported parameters are omitted from a non-streaming OpenAI request, an array of human-readable warnings is added to _devup.warnings. Streamed responses do not carry _devup, so parameters dropped on a streamed request are not visible to the client.

The warnings key is absent when no parameters are dropped (including on all DEFAULT model requests).
Warnings identify the parameter name only and never echo user values, prompt text, or credentials.
Warnings are sorted deterministically in alphabetical order.
_devup.request_id (string) equals the x-request-id response header.

Example Response with Warnings

{
  "id": "chatcmpl-79037612-d7c2-43e0-8494-c560f97c61ea",
  "object": "chat.completion",
  "created": 1725884000,
  "model": "openai/gpt-5.6-luna",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": "Entropy represents the degree of disorder or randomness in a physical system."
      },
      "finish_reason": "stop"
    }
  ],
  "usage": {
    "prompt_tokens": 18,
    "completion_tokens": 15,
    "total_tokens": 33
  },
  "_devup": {
    "request_id": "req_9fd8ddec5b2149539860a86dccba58cf",
    "warnings": [
      "This model does not take the 'temperature' parameter; the request was answered without it.",
      "This model does not take the 'top_p' parameter; the request was answered without it."
    ]
  }
}

Abridged: _devup also includes cost_dzd and balance_dzd.

The values shown above are illustrative.

5. Reasoning models and token budgets

Reasoning-capable models, such as the model identified by openai/gpt-5.6-luna in the examples on this page, perform internal computation before generating visible output.

Reasoning tokens consume your completion budget

Internal reasoning tokens count against your max_tokens (or max_completion_tokens) budget and are billed as output tokens.

If your configured ceiling is too low, the model consumes its entire allocation thinking through the problem and terminates with an empty string (content: ""). This is how these models work: raise the ceiling to get an answer.

Measured behavior from production:

10-token ceiling: Returned content: "". All 10 tokens were consumed by internal reasoning.
400-token ceiling: Returned a full answer with 95 completion tokens, of which 13 were internal reasoning tokens and 82 were visible response tokens.

Recommendation: We recommend a starting floor of at least max_tokens: 100 to max_tokens: 200 for trivial questions, and higher ceilings for complex analysis. This floor is an operational starting point, not a guarantee.

For deeper architectural details on how reasoning models function across DEVUP AI, see the Reasoning Models guide.

6. What is not yet available

OpenAI models are available on the Chat Completions endpoint (POST /v1/chat/completions) resolves destinations to OpenAI models.

The following capabilities are not currently available for OpenAI models on DEVUP AI:

Embeddings: /v1/embeddings routes to DEFAULT models only.
Image Generation: /v1/images/generations routes to DEFAULT models only.
Speech & Audio: Audio synthesis (/v1/audio/speech) and transcription (/v1/audio/transcriptions) route to DEFAULT models only.
Video Generation: /v1/video/generations routes to DEFAULT models only.
Reranking: /v1/rerank routes to DEFAULT models only.

7. Billing

OpenAI models on DEVUP AI are metered and billed in Algerian Dinar (DZD) per million tokens, matching our platform standard.

Internal reasoning tokens count as completion tokens and are billed at the model's standard output token rate.
All current rates are displayed live on each model's entry in the Model Catalog.
When present on non-streaming responses, settled cost is included in _devup.cost_dzd and your remaining account balance in _devup.balance_dzd.

8. Models served on /v1/responses

Some models are served exclusively on /v1/responses and do not support Chat Completions. Other models support Chat Completions for text generation, but support tool calling only on /v1/responses.

Each model page in the Model Catalog indicates whether the model or its tool calling requires /v1/responses. In GET /v1/models, tool_calls.chat_completions is false for both kinds of model, so a client can tell before it sends a request with tools.

When a Chat Completions request targets a model that is served only on /v1/responses, or includes tools on a model where tool calling requires it, the answer is HTTP 400 and error code use_responses_api directing callers to /v1/responses rather than a generic error.