Responses

POST /v1/responses accepts requests in the OpenAI Responses format. The Gateway rejects unsupported fields, and any field not listed here, with 400. A field with an empty “Provider differences” cell behaves the same whichever of OpenAI, Anthropic, Gemini, DeepSeek, and Kimi is assigned. Gemini called through Vertex AI behaves like Gemini on this page, except that its reasoning items carry format: google-vertex-v1.

The shared rules and error sources are in the Gateway overview. Fields that share a name with Chat Completions follow the same rules as Chat Completions.

Conversation state

The Gateway does not store responses. It always sends store: false to OpenAI and does not accept previous_response_id, conversation, or item_reference, which point to stored responses or conversations. To continue a conversation, append the items in the response output to the next request’s input as they are.

The response id is the Gateway request ID starting with abto-, the same as the x-abto-request-id header.

Provider differences at a glance

• A request assigned to OpenAI is sent in the Responses format as it is. A request assigned to another provider is converted to that provider’s API format.
• On Anthropic and Gemini, instructions is joined with the other system and developer messages in the system prompt slot. On DeepSeek and Kimi it is sent as the leading system message.
• Only OpenAI and Gemini apply reasoning.summary. Gemini does not choose a summary length, so concise and detailed also return its default summary.
• The Gateway gives items produced by other providers an OpenAI-style id starting with msg_, fc_, or rs_. These items can be sent as they are even when a later turn is assigned to OpenAI.
• Anthropic requires a maximum token count. When max_output_tokens is omitted, the Gateway sends that model’s output ceiling.

Request fields

Input and messages

Field	Support	Provider differences
model	Supported
instructions	Supported	Anthropic, Gemini: joined into the system prompt
input (string)	Supported
input[] message (user, assistant, system, developer)	Supported	Anthropic, Gemini: system and developer are concatenated into one message at the front
input[].content[] input_text	Supported (user, system, and developer messages)
input[].content[] output_text	Supported (assistant messages)
input[].content[] input_image	Supported (base64 data URL or http(s) URL)	Same as image_url in Chat Completions
input[].content[] input_file	Supported (base64 PDF data URL only)	Same as file in Chat Completions
input[].content[].detail	Supported (auto, low, high, original)	Gemini: applies only low and high on images Anthropic: not applied
input[].id	Supported	Providers other than OpenAI: not applied
input[].phase (assistant)	Supported	Providers other than OpenAI: not applied

• System prompt: instructions is a system prompt just like the system and developer messages. When the node allows system prompts, requests assigned to a variant with a system prompt use the variant’s system prompt.
• Media: Images and PDFs are accepted only in user messages, in the same forms as Chat Completions. original in detail is accepted only on input_image.
• Sending output items back: The items in the response output can be sent as they are. status is accepted but not sent to the provider, and the annotations and logprobs of output_text are accepted only as empty arrays.

Output length and streaming

Field	Support	Provider differences
max_output_tokens	Supported	Anthropic: the model’s output ceiling when omitted
stream	Streaming not supported (false only)
store	Storing responses not supported (false only)
background	Background runs not supported (false only)
truncation	Automatic truncation not supported (disabled only)

Generation parameters

Field	Support	Provider differences
temperature	Supported	Same as Chat Completions
top_p	Supported	Same as Chat Completions
reasoning.effort	Supported	DeepSeek, Kimi: the accepted values differ from OpenAI, so check them in the dashboard
text.verbosity	Supported	DeepSeek, Kimi: not applied
reasoning.summary	Supported (auto, concise, detailed)	Gemini: does not choose a length Anthropic, DeepSeek, Kimi: not applied

• Once routing is configured: Generation parameters come from the assigned variant. The rules are the same as Chat Completions.
• Variants and request formats: An OpenAI variant serves both Chat Completions and Responses requests. For a Responses request, reasoning_effort is sent as reasoning.effort and verbosity as text.verbosity, and seed, frequency_penalty, and presence_penalty are not sent. For a Chat Completions request the names are converted the other way, and a reasoning.effort of max is sent as xhigh. The dashboard shows parameters under the names of the format of the latest request to the node.

Output format

Field	Support	Provider differences
text.format: text	Supported
text.format: json_schema	Supported	Same as json_schema in Chat Completions
text.format: json_object	Supported	Same as json_object in Chat Completions

• Shape: text.format holds type, name, description, strict, and schema in one object. Other keys are not forwarded to the provider.
• Combination rule: json_object cannot be combined with tools.

Tool calling

Field	Support	Provider differences
tools	Supported (type: function only)
tools[].strict	Supported	When omitted, OpenAI attempts strict mode and other providers call without it Gemini: if any tool is true, every tool is validated
tool_choice	Supported (none, auto, required, a named function)
tool_choice: allowed_tools	Supported (mode is auto or required only)	Anthropic, DeepSeek, Kimi: tools outside the allowed list are left out of the request
parallel_tool_calls	Turning off parallel calls not supported (true only)
input[] function_call	Supported
input[] function_call_output	Supported (string or input_text parts)

• Returning results: Send the call_id of function_call and of function_call_output exactly as you received it. arguments must be a JSON object string.

Reasoning

Field	Support	Provider differences
input[] reasoning	Supported	Not sent when the request is assigned to a provider other than the one that produced it
include: ["reasoning.encrypted_content"]	Supported

• What comes back: Reasoning models return a reasoning item in output. An item produced by OpenAI holds a value only the provider can read in encrypted_content, and a summary in summary when reasoning.summary was requested.
• Reasoning from other providers: Items produced by Anthropic, Gemini, DeepSeek, and Kimi carry format, which names the provider that produced the reasoning, and Anthropic and Gemini signatures are in signature. Items produced by OpenAI have no format.
• Carrying it to the next turn: Send reasoning items in the next request’s input without changing them. The Gateway sends an item only to requests assigned to the provider that produced it.
• Keep a conversation on one variant: Send the same x-abto-device-id on every request of a multi-turn conversation. Without it each request is assigned on its own, and once the provider changes the earlier reasoning is not used and the model reasons again.
• Sending directly to OpenAI: OpenAI rejects items that carry format or signature. When a conversation sent directly to OpenAI, without the Gateway, contains reasoning items produced by other providers, leave those items out.

Response

The response is in the OpenAI Responses format. It differs from Chat Completions as follows.

• Completion status: status is completed or incomplete. When it is incomplete, incomplete_details.reason is max_output_tokens (the output ceiling or the context length) or content_filter (blocked or refused).
• Request values: tools, tool_choice, max_output_tokens, text.format, and instructions return the values sent in the request. temperature and top_p, which the variant decides, are null, and reasoning is not included. Check the assigned provider in the x-abto-provider header and the model in model.
• Fixed values: store is false, parallel_tool_calls is true, and truncation is disabled.

Unsupported fields

The Gateway rejects the fields below with 400. Fields that appear in no table are rejected the same way.

Group	Fields
Stored state	previous_response_id, conversation, prompt, context_management, input[] item_reference
Provider built-in tools	tools in tools other than functions, such as web_search, built-in tool items such as web_search_call, max_tool_calls
Generation parameters Responses does not have	seed, frequency_penalty, presence_penalty, reasoning_effort, verbosity
Provider-specific settings	reasoning.mode, reasoning.context, service_tier
File references	input_image.file_id, input_file.file_id, input_file.file_url, an http(s) URL in input_file.file_data
Other	include values other than reasoning.encrypted_content, refusal parts, top_logprobs, stream_options, metadata, user, safety_identifier, prompt_cache_key, prompt_cache_retention

Provider API references

The Gateway sends requests assigned to OpenAI to the Responses API. The API formats of the other providers are the same as Chat Completions.