> ## Documentation Index
> Fetch the complete documentation index at: https://docs.mka1.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Text generation

> Use the MKA1 API Responses resource to generate text, send structured messages, and continue multi-turn exchanges.

<div className="legacy-section-link">
  <span id="stream-text-as-it-is-generated" />

  <p>This section has moved to <a href="/docs/streaming">Streaming</a>.</p>
</div>

Use the Responses resource when you want the MKA1 API to return text.
Start with a plain string for simple prompts.
Use message items when you need explicit roles or conversation state.
Later sections cover sampling and length limits, reasoning effort, and the request fields the gateway drops. Pausing a background response has its own section in [background responses](/docs/background-responses#pause-and-wake).

## Send a simple prompt

Pass a string in `input` for a single-turn request.
The response includes generated text in `output_text`.
If a guardrail blocks the request, `output_text` is absent and the output carries a refusal instead; see [Guardrails](/docs/guardrails#detect-a-block-in-code).

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  import { SDK } from '@meetkai/mka1';
  import type { ResponseObject } from '@meetkai/mka1/models/components';

  const sdk = new SDK({ bearerAuth: 'Bearer <mka1-api-key>' });

  const result = await sdk.llm.responses.create({
    xOnBehalfOf: '<end-user-id>', // optional — attribute the request to one of your end users
    responsesCreateRequest: {
      model: 'auto',
      input: 'Write a one-sentence summary of the MKA1 API.',
    },
  });
  ```

  ```ts OpenAI SDK theme={null}
  import OpenAI from 'openai';

  const openai = new OpenAI({
    apiKey: '<mka1-api-key>',
    baseURL: 'https://apigw.mka1.com/api/v1/llm/',
    defaultHeaders: { 'X-On-Behalf-Of': '<end-user-id>' },
  });

  const response = await openai.responses.create({
    model: 'auto',
    input: 'Write a one-sentence summary of the MKA1 API.',
    stream: false,
  });
  ```

  ```python Python SDK theme={null}
  from meetkai_mka1 import SDK

  sdk = SDK(bearer_auth="Bearer <mka1-api-key>")

  res = sdk.llm.responses.create(
      model="auto",
      input="Write a one-sentence summary of the MKA1 API.",
      x_on_behalf_of="<end-user-id>",  # optional — attribute the request to one of your end users
  )
  ```

  ```csharp C# SDK theme={null}
  using MeetKai.MKA1;
  using MeetKai.MKA1.Types.Components;

  var sdk = new SDK(bearerAuth: "Bearer <mka1-api-key>");

  var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "auto",
      Input = ResponsesCreateRequestInput.CreateStr(
          "Write a one-sentence summary of the MKA1 API."),
  });
  ```

  ```bash CLI theme={null}
  mka1 llm responses create \
    --model auto \
    --input '"Write a one-sentence summary of the MKA1 API."' \
    -H 'X-On-Behalf-Of: <end-user-id>'
  ```

  ```bash Bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/responses \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "model": "auto",
      "input": "Write a one-sentence summary of the MKA1 API."
    }'
  ```
</CodeGroup>

If you are not acting for an end user, omit `X-On-Behalf-Of`.

## Add instructions

Use `instructions` to define behavior before the model sees the user input.
Keep instructions short and specific.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.llm.responses.create({
    responsesCreateRequest: {
      model: 'auto',
      instructions: 'You are a support assistant. Reply in plain English. Keep answers under 80 words.',
      input: 'Explain what embeddings are used for.',
    },
  });
  ```

  ```ts OpenAI SDK theme={null}
  const response = await openai.responses.create({
    model: 'auto',
    instructions: 'You are a support assistant. Reply in plain English. Keep answers under 80 words.',
    input: 'Explain what embeddings are used for.',
    stream: false,
  });
  ```

  ```python Python SDK theme={null}
  res = sdk.llm.responses.create(
      model="auto",
      instructions="You are a support assistant. Reply in plain English. Keep answers under 80 words.",
      input="Explain what embeddings are used for.",
  )
  ```

  ```csharp C# SDK theme={null}
  var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "auto",
      Instructions = "You are a support assistant. Reply in plain English. Keep answers under 80 words.",
      Input = ResponsesCreateRequestInput.CreateStr("Explain what embeddings are used for."),
  });
  ```

  ```bash CLI theme={null}
  mka1 llm responses create \
    --model auto \
    --instructions 'You are a support assistant. Reply in plain English. Keep answers under 80 words.' \
    --input '"Explain what embeddings are used for."'
  ```

  ```bash Bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/responses \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "model": "auto",
      "instructions": "You are a support assistant. Reply in plain English. Keep answers under 80 words.",
      "input": "Explain what embeddings are used for."
    }'
  ```
</CodeGroup>

## Send structured messages

Use an array of message items in `input` when you want explicit roles.
Each message item uses `type`, `role`, and `content`.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.llm.responses.create({
    responsesCreateRequest: {
      model: 'auto',
      input: [
        { type: 'message', role: 'developer', content: 'Answer as a technical writer. Keep the reply concise.' },
        { type: 'message', role: 'user', content: 'Draft a short product update about faster response times.' },
      ],
    },
  });
  ```

  ```ts OpenAI SDK theme={null}
  const response = await openai.responses.create({
    model: 'auto',
    input: [
      { type: 'message', role: 'developer', content: 'Answer as a technical writer. Keep the reply concise.' },
      { type: 'message', role: 'user', content: 'Draft a short product update about faster response times.' },
    ],
    stream: false,
  });
  ```

  ```python Python SDK theme={null}
  res = sdk.llm.responses.create(
      model="auto",
      input=[
          {"type": "message", "role": "developer", "content": "Answer as a technical writer. Keep the reply concise."},
          {"type": "message", "role": "user", "content": "Draft a short product update about faster response times."},
      ],
  )
  ```

  ```csharp C# SDK theme={null}
  var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "auto",
      Input = ResponsesCreateRequestInput.CreateArrayOfItem(new List<Item>
      {
          Item.CreateInputMessage(new InputMessage()
          {
              Role = InputMessageRole.Developer,
              Content = InputMessageContent1.CreateStr(
                  "Answer as a technical writer. Keep the reply concise."),
          }),
          Item.CreateInputMessage(new InputMessage()
          {
              Role = InputMessageRole.User,
              Content = InputMessageContent1.CreateStr(
                  "Draft a short product update about faster response times."),
          }),
      }),
  });
  ```

  ```bash CLI theme={null}
  mka1 llm responses create --body '{
    "model": "auto",
    "input": [
      { "type": "message", "role": "developer", "content": "Answer as a technical writer. Keep the reply concise." },
      { "type": "message", "role": "user", "content": "Draft a short product update about faster response times." }
    ]
  }'
  ```

  ```bash Bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/responses \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "model": "auto",
      "input": [
        { "type": "message", "role": "developer", "content": "Answer as a technical writer. Keep the reply concise." },
        { "type": "message", "role": "user", "content": "Draft a short product update about faster response times." }
      ]
    }'
  ```
</CodeGroup>

This pattern is useful when you want the request body to carry the message history directly.

## Continue a multi-turn exchange

Use `previous_response_id` to continue from an earlier response without resending the full history.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const second = await sdk.llm.responses.create({
    responsesCreateRequest: {
      model: 'auto',
      previousResponseId: 'resp_123',
      input: 'Now turn that into an email subject line.',
    },
  });
  ```

  ```ts OpenAI SDK theme={null}
  const second = await openai.responses.create({
    model: 'auto',
    previous_response_id: 'resp_123',
    input: 'Now turn that into an email subject line.',
    stream: false,
  });
  ```

  ```python Python SDK theme={null}
  res = sdk.llm.responses.create(
      model="auto",
      previous_response_id="resp_123",
      input="Now turn that into an email subject line.",
  )
  ```

  ```csharp C# SDK theme={null}
  // First request
  var first = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "auto",
      Input = ResponsesCreateRequestInput.CreateStr("Write a one-line product tagline."),
  });

  // Second request: continue from the first response
  var second = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "auto",
      PreviousResponseId = first.Id,
      Input = ResponsesCreateRequestInput.CreateStr("Now turn that into an email subject line."),
  });
  ```

  ```bash CLI theme={null}
  mka1 llm responses create \
    --model auto \
    --previous-response-id resp_123 \
    --input '"Now turn that into an email subject line."'
  ```

  ```bash Bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/responses \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "model": "auto",
      "previous_response_id": "resp_123",
      "input": "Now turn that into an email subject line."
    }'
  ```
</CodeGroup>

If you need a reusable conversation container, create one with the Conversations resource and then pass the conversation ID in `conversation`.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const conv = await sdk.llm.conversations.create({
    createConversationRequest: {
      metadata: { session_id: 'web-42' },
    },
  });

  const result = await sdk.llm.responses.create({
    responsesCreateRequest: {
      model: 'auto',
      conversation: conv.id,
      input: 'What should I ask next to refine this draft?',
    },
  });
  ```

  ```ts OpenAI SDK theme={null}
  const conv = await openai.conversations.create({
    metadata: { session_id: 'web-42' },
  });

  const response = await openai.responses.create({
    model: 'auto',
    conversation: conv.id,
    input: 'What should I ask next to refine this draft?',
    stream: false,
  });
  ```

  ```python Python SDK theme={null}
  conv = sdk.llm.conversations.create(
      create_conversation_request={
          "metadata": {"session_id": "web-42"},
      },
  )

  res = sdk.llm.responses.create(
      model="auto",
      conversation=conv.id,
      input="What should I ask next to refine this draft?",
  )
  ```

  ```csharp C# SDK theme={null}
  var conv = await sdk.Llm.Conversations.CreateAsync(body: new CreateConversationRequest()
  {
      Metadata = new Dictionary<string, string> { { "session_id", "web-42" } },
  });
  ```

  ```bash CLI theme={null}
  # Create a conversation
  mka1 llm conversations create --body '{
    "metadata": { "session_id": "web-42" }
  }'

  # Use the conversation in a response request
  mka1 llm responses create \
    --model auto \
    --conversation conv_123 \
    --input '"What should I ask next to refine this draft?"'
  ```

  ```bash Bash theme={null}
  # Create conversation
  curl https://apigw.mka1.com/api/v1/llm/conversations \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "metadata": { "session_id": "web-42" }
    }'

  # Use conversation in a response request
  curl https://apigw.mka1.com/api/v1/llm/responses \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "model": "auto",
      "conversation": "conv_123",
      "input": "What should I ask next to refine this draft?"
    }'
  ```
</CodeGroup>

Note: deleting a conversation does not delete its items.

See the Conversations and Responses pages in the [API Reference](/api-reference/introduction) for the full resource workflow.

## Stream a response

See [Streaming](/docs/streaming) for complete client examples.

## Tune sampling and length

Sampling fields change how the model picks each token. Length fields cap how much it writes.
All of them are optional and sit at the top level of the request, next to `model` and `input`.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.llm.responses.create({
    responsesCreateRequest: {
      model: 'auto',
      input: 'Write a one-sentence summary of the MKA1 API.',
      temperature: 0.2,
      maxOutputTokens: 400,
    },
  });
  ```

  ```ts OpenAI SDK theme={null}
  const response = await openai.responses.create({
    model: 'auto',
    input: 'Write a one-sentence summary of the MKA1 API.',
    temperature: 0.2,
    max_output_tokens: 400,
    stream: false,
  });
  ```

  ```python Python SDK theme={null}
  res = sdk.llm.responses.create(
      model="auto",
      input="Write a one-sentence summary of the MKA1 API.",
      temperature=0.2,
      max_output_tokens=400,
  )
  ```

  ```csharp C# SDK theme={null}
  var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "auto",
      Input = ResponsesCreateRequestInput.CreateStr(
          "Write a one-sentence summary of the MKA1 API."),
      Temperature = 0.2,
      MaxOutputTokens = 400,
  });
  ```

  ```bash CLI theme={null}
  mka1 llm responses create --body '{
    "model": "auto",
    "input": "Write a one-sentence summary of the MKA1 API.",
    "temperature": 0.2,
    "max_output_tokens": 400
  }'
  ```

  ```bash Bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/responses \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "model": "auto",
      "input": "Write a one-sentence summary of the MKA1 API.",
      "temperature": 0.2,
      "max_output_tokens": 400
    }'
  ```
</CodeGroup>

The gateway validates every value before it calls the model. A value outside its range returns `400`. In the example, check `status`: if the model hit the 400-token cap, the response is `incomplete` rather than `completed`, and `usage.output_tokens` stays at or below the cap. Some fields below are gateway extensions. They are not part of the OpenAI Responses API, and whether they reach the model depends on its upstream, the provider API the gateway forwards your request to, which speaks either the Responses format or the Completions format.

| Field | Accepts | Effect |
| - | - | - |
| `temperature` | number, 0 to 2 | How random each token pick is. Lower values give steadier output. |
| `top_p` | number, 0 to 1 | Nucleus sampling. The model only considers the tokens that make up the top `top_p` share of probability. Use this or `temperature`, not both. |
| `max_output_tokens` | integer, 1 or more | Cap on generated tokens. A response cut off at the cap finishes with `status: "incomplete"`. |
| `stop` | string, or a non-empty array of strings | Stop sequences. Gateway extension. |
| `presence_penalty` | number, -2 to 2 | Penalizes tokens that have already appeared, so the model moves on to new topics. |
| `frequency_penalty` | number, -2 to 2 | Penalizes tokens by how often they have appeared, so the model repeats itself less. |
| `top_k` | integer, 0 or more | Provider-specific top-k sampling. Gateway extension. |
| `min_p` | number, 0 to 1 | Provider-specific min-p sampling. Gateway extension. |
| `repetition_penalty` | number, 0 or more | Provider-specific repetition penalty. Gateway extension. |
| `do_sample` | boolean | Provider-specific sampling toggle. Gateway extension. |
| `truncation` | `"auto"` or `"disabled"`, default `"auto"` | What happens when the input outgrows the context window. `auto` drops the oldest messages; with `disabled` the response fails with status `failed`. |

Fields marked as gateway extensions are not part of the OpenAI Responses API, so the OpenAI SDK's types do not know them. Send them with the MKA1 SDK, the CLI, or raw HTTP.

Four more gateway extensions pass provider options through untouched: `chat_template_kwargs` (for example `{"enable_thinking": false}`), `prefill_think` (a boolean or prefill text), `use_cache`, and `extra_body`, an object merged into the upstream request after the gateway strips any auth, base-URL, and header keys from it.

Not every field reaches every model. [Fields the gateway drops](#fields-the-gateway-drops) lists the cases.

### Check what a model supports

Not every model accepts every field. `GET /api/v1/llm/models/{model_id}` returns a `capabilities` object with four booleans:

| Flag | `true` means |
| - | - |
| `supports_temperature` | The model accepts `temperature`. |
| `supports_top_p` | The model accepts `top_p`. |
| `supports_reasoning` | The model reasons before it answers, so part of its output tokens go to reasoning. |
| `supports_reasoning_effort` | The model accepts `reasoning.effort`. A reasoning model can report `false` here: it still reasons, but ignores the effort level. |

Models that are not LLMs (embeddings, images, speech) report `false` for all four. The model object also lists `input_modalities` and `output_modalities`, the kinds of content the model accepts and produces, such as `["text", "image"]`.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const model = await sdk.llm.models.get({ modelId: 'meetkai:functionary' });

  console.log(model.capabilities, model.inputModalities);
  ```

  ```ts OpenAI SDK theme={null}
  const model = await openai.models.retrieve('meetkai:functionary');

  // capabilities and input_modalities are gateway extensions, so the OpenAI SDK's Model type does not declare them
  const { capabilities, input_modalities } = model as unknown as {
    capabilities: {
      supports_temperature: boolean;
      supports_top_p: boolean;
      supports_reasoning: boolean;
      supports_reasoning_effort: boolean;
    };
    input_modalities: string[];
  };
  console.log(capabilities, input_modalities);
  ```

  ```python Python SDK theme={null}
  model = sdk.llm.models.get(model_id="meetkai:functionary")

  print(model.capabilities, model.input_modalities)
  ```

  ```csharp C# SDK theme={null}
  var model = await sdk.Llm.Models.GetAsync(modelId: "meetkai:functionary");

  var capabilities = model.Object!.Capabilities;
  Console.WriteLine($"{capabilities.SupportsTemperature} {capabilities.SupportsTopP} {capabilities.SupportsReasoning} {capabilities.SupportsReasoningEffort}");
  Console.WriteLine(string.Join(", ", model.Object!.InputModalities));
  ```

  ```bash CLI theme={null}
  mka1 llm models get --model-id meetkai:functionary
  ```

  ```bash Bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/models/meetkai:functionary \
    --header 'Authorization: Bearer <mka1-api-key>'
  ```
</CodeGroup>

If you send a field to a model that reports `false` for it, the gateway does not reject the request. It drops that one field before calling the model, forwards everything else, and the model uses its own default for that setting. Nothing in the response says the field was dropped: it echoes `temperature`, `top_p`, and `reasoning` exactly as you sent them. Check the model's capabilities first when the setting matters.

## Control reasoning

Reasoning models think before they answer. The `reasoning` object sets how much thinking you want and whether you see it:

* `effort`: `none`, `minimal`, `low`, `medium`, `high`, or `xhigh`.
* `summary`: `auto`, `concise`, or `detailed`. Asks the model to return a readable summary of its reasoning.

Both keys must be present whenever you send the object. Set the one you are not using to `null`. `{"effort": "low"}` on its own fails validation.

Each key reaches the model only when the model can use it:

* `effort` goes only to models that report `supports_reasoning_effort: true`. A Completions-format upstream receives it as `reasoning_effort`.
* `summary` goes only to models that report `supports_reasoning: true` and whose upstream speaks the Responses format.

The gateway drops a key the model cannot use, and the request still succeeds.

<CodeGroup>
  ```ts TypeScript SDK theme={null}
  const result = await sdk.llm.responses.create({
    responsesCreateRequest: {
      model: 'auto',
      input: 'Which of 17, 21, and 23 are prime? Answer in one line.',
      reasoning: { effort: 'low', summary: null },
    },
  }) as ResponseObject;

  console.log(result.usage.outputTokensDetails.reasoningTokens);
  ```

  ```ts OpenAI SDK theme={null}
  const response = await openai.responses.create({
    model: 'auto',
    input: 'Which of 17, 21, and 23 are prime? Answer in one line.',
    reasoning: { effort: 'low', summary: null },
    stream: false,
  });

  console.log(response.usage?.output_tokens_details.reasoning_tokens);
  ```

  ```python Python SDK theme={null}
  res = sdk.llm.responses.create(
      model="auto",
      input="Which of 17, 21, and 23 are prime? Answer in one line.",
      reasoning={"effort": "low", "summary": None},
  )

  print(res.usage.output_tokens_details.reasoning_tokens)
  ```

  ```csharp C# SDK theme={null}
  var res = await sdk.Llm.Responses.CreateAsync(new ResponsesCreateRequest()
  {
      Model = "auto",
      Input = ResponsesCreateRequestInput.CreateStr(
          "Which of 17, 21, and 23 are prime? Answer in one line."),
      Reasoning = new ReasoningConfiguration()
      {
          Effort = ReasoningConfigurationEffort.Low,
          Summary = null,
      },
  });

  Console.WriteLine(res.ResponseObject!.Usage.OutputTokensDetails.ReasoningTokens);
  ```

  ```bash CLI theme={null}
  mka1 llm responses create --body '{
    "model": "auto",
    "input": "Which of 17, 21, and 23 are prime? Answer in one line.",
    "reasoning": { "effort": "low", "summary": null }
  }'
  ```

  ```bash Bash theme={null}
  curl https://apigw.mka1.com/api/v1/llm/responses \
    --request POST \
    --header 'Content-Type: application/json' \
    --header 'Authorization: Bearer <mka1-api-key>' \
    --header 'X-On-Behalf-Of: <end-user-id>' \
    --data '{
      "model": "auto",
      "input": "Which of 17, 21, and 23 are prime? Answer in one line.",
      "reasoning": { "effort": "low", "summary": null }
    }'
  ```
</CodeGroup>

The OpenAI SDK's `ReasoningEffort` type does not include `none` or `xhigh`; send those with the MKA1 SDK, the CLI, or raw HTTP.

Reasoning shows up in three places:

* `output` can contain an item with `type: "reasoning"`. Its `summary` array holds `summary_text` parts, and `content` (when present) holds the raw `reasoning_text` parts. Add `"reasoning.encrypted_content"` to `include` to get `encrypted_content` as well.
* `usage.output_tokens_details.reasoning_tokens` is the share of `output_tokens` the model spent thinking. Reasoning tokens are output tokens, so they count against `max_output_tokens`.
* In a stream, `response.reasoning_text.delta` and `response.reasoning_summary_text.delta` events typically arrive before the `response.output_text.delta` events. The [streaming output latency](/docs/streaming-output-latency) benchmark shows this order on a live model.

To know before the call whether a model reasons and whether it accepts `effort`, read `supports_reasoning` and `supports_reasoning_effort` as shown in [Check what a model supports](#check-what-a-model-supports). After the call, `usage.output_tokens_details.reasoning_tokens` shows how much reasoning happened.

When you send `model: "auto"`, the gateway applies the organization's auto
policy for Responses. The default is a direct model-registry alias. An
organization admin can configure a balanced policy that asks an LLM judge to
choose among eligible models using capability, price, gateway latency,
comparable evals, request requirements, and conversation continuity. Routing
does not change the `reasoning.effort` you send, but the gateway still drops it
when the chosen model reports `supports_reasoning_effort: false`. [Auto routing](/docs/auto-routing) explains the policy and its failure and
privacy behavior.

## Fields the gateway drops

Each field below passes validation, but the gateway drops it before calling the model in the case listed. A dropped field never fails the request, and nothing in the response says it was dropped. Some cases depend on the model's upstream, the provider API the gateway forwards your request to.

| Field | Dropped when |
| - | - |
| `temperature` | The model reports `supports_temperature: false`. |
| `top_p` | The model reports `supports_top_p: false`. |
| `reasoning.effort` | The model reports `supports_reasoning_effort: false`. |
| `reasoning.summary` | The model reports `supports_reasoning: false`, or its upstream speaks the Completions format. |
| `text.verbosity` | The model's upstream speaks the Completions format. |
| `stop` | The model's upstream speaks the Responses format at `api.openai.com`. |
| `top_k`, `min_p`, `repetition_penalty`, `do_sample`, `chat_template_kwargs`, `prefill_think`, `use_cache`, `extra_body` | The model's upstream is at `api.openai.com`. |
| `top_logprobs`, `service_tier`, `prompt_cache_key`, `safety_identifier`, `user` | Always. The gateway accepts them for OpenAI compatibility but does not send them to the model. |
| Any field the Responses API does not define | Always. The gateway removes it without an error. |

Because unknown fields are removed silently, a misspelled field name looks accepted but has no effect. If a setting seems to do nothing, compare your request with the [API reference](/api-reference/introduction).

## Pause a background response

A background response can call the `sleep` tool to wait up to 20 minutes for a webhook or an outside job, and you can wake it early with follow-up input. See [background responses](/docs/background-responses#pause-and-wake).

## Next steps

* Review the [API overview](/api-reference/introduction) for authentication and base URL details
* See [background responses](/docs/background-responses) when you need to offload long-running work and poll or stream for results
* See [manage conversations](/docs/conversations) to organize multi-turn exchanges into reusable conversation containers
* See [manage agents](/docs/managing-agents) when you want reusable agent definitions and persisted runs
* See [streaming output latency](/docs/streaming-output-latency) for measured time to first streamed token on the Responses API


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.