Create a model response

POST

responses

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cometapi.com/v1",
    api_key=os.environ["COMETAPI_KEY"],
)

response = client.responses.create(
    model="gpt-6-astra",
    input="Tell me a three sentence bedtime story about a unicorn.",
    reasoning={
        "effort": "low",
    },
)

print(response.output_text)

{
  "id": "resp_example",
  "object": "response",
  "created_at": 1788763707,
  "status": "completed",
  "background": false,
  "completed_at": 1788763711,
  "error": null,
  "incomplete_details": null,
  "model": "gpt-6-astra",
  "output": [
    {
      "id": "msg_example",
      "type": "message",
      "status": "completed",
      "content": [
        {
          "type": "output_text",
          "annotations": [],
          "logprobs": [],
          "text": "A little unicorn named Luna followed a trail of silver fireflies to a meadow where the flowers chimed softly in the breeze. She curled beneath a willow tree, tucked her hooves into the cool grass, and wished sweet dreams for every creature in the forest. As the moon wrapped the meadow in gentle light, Luna closed her eyes and drifted into dreams of dancing among the stars."
        }
      ],
      "phase": "final_answer",
      "role": "assistant"
    }
  ],
  "parallel_tool_calls": true,
  "previous_response_id": null,
  "reasoning": {
    "context": "all_turns",
    "effort": "low",
    "mode": "standard",
    "summary": null
  },
  "store": true,
  "text": {
    "format": {
      "type": "text"
    },
    "verbosity": "medium"
  },
  "tool_choice": "auto",
  "tools": [],
  "usage": {
    "input_tokens": 17,
    "input_tokens_details": {
      "cache_write_tokens": 0,
      "cached_tokens": 0
    },
    "output_tokens": 81,
    "output_tokens_details": {
      "reasoning_tokens": 0
    },
    "total_tokens": 98
  }
}

Use the Responses API to send text, images, files, and conversation history with gpt-6-astra. The examples also demonstrate web search, custom function calls, structured output, reasoning, and streaming.

The OpenAI Responses reference describes the full API format; the examples here configure that format for CometAPI.

Continue a conversation

For a text-only conversation, keep the user messages and assistant text replies, then add the next user message:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cometapi.com/v1",
    api_key=os.environ["COMETAPI_KEY"],
)

input_items = [
    {"role": "user", "content": "My project is named Cedar and uses Python. Remember these two facts."}
]

response = client.responses.create(
    model="gpt-6-astra",
    input=input_items,
    reasoning={"effort": "low"},
)

input_items.append({"role": "assistant", "content": response.output_text})
input_items.append({
    "role": "user",
    "content": "What is my project's name and programming language?",
})

follow_up = client.responses.create(
    model="gpt-6-astra",
    input=input_items,
    reasoning={"effort": "low"},
)

print(follow_up.output_text)

response.output_text is an SDK convenience property that combines assistant text from the response. Function-calling conversations also need their tool-call and result items, as described below.

Use web search

Add a web_search tool to search for information and include source citations:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cometapi.com/v1",
    api_key=os.environ["COMETAPI_KEY"],
)

response = client.responses.create(
    model="gpt-6-astra",
    input="Search the web for the NASA Artemis II mission overview and cite the official NASA page.",
    tools=[
        {
            "type": "web_search",
        },
    ],
    reasoning={
        "effort": "low",
    },
)

print(response.output_text)

Inspect the returned web_search_call items and the message’s URL annotations when your application needs search results or citations. Other built-in tools require their own configuration; see the OpenAI tools guide.

Call custom functions

Define the function arguments and let the model request the function:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cometapi.com/v1",
    api_key=os.environ["COMETAPI_KEY"],
)

response = client.responses.create(
    model="gpt-6-astra",
    input="What is the weather in Boston, MA, in celsius? Use the weather tool.",
    tools=[
        {
            "type": "function",
            "name": "get_current_weather",
            "description": "Get the current weather for a city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {
                        "type": "string",
                        "description": "City and state, for example Boston, MA.",
                    },
                    "unit": {
                        "type": "string",
                        "enum": [
                            "celsius",
                            "fahrenheit",
                        ],
                        "description": "Temperature unit.",
                    },
                },
                "required": [
                    "location",
                    "unit",
                ],
                "additionalProperties": False,
            },
            "strict": True,
        },
    ],
    tool_choice="auto",
    reasoning={
        "effort": "low",
    },
)

print(response.output)

A function call appears as a function_call output item. Its arguments field is a JSON-encoded string. Execute your function, then build the next request from the original input and returned output items without their response-item id fields. Keep the function’s name, arguments, and call_id, and append a function_call_output item with the matching call_id and your result in output.

Request structured output

Use text.format to request JSON that follows a schema:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cometapi.com/v1",
    api_key=os.environ["COMETAPI_KEY"],
)

response = client.responses.create(
    model="gpt-6-astra",
    input="List 3 programming languages with their main use cases.",
    text={
        "format": {
            "type": "json_schema",
            "name": "languages",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {
                    "languages": {
                        "type": "array",
                        "items": {
                            "type": "object",
                            "properties": {
                                "name": {
                                    "type": "string",
                                    "description": "Programming language name.",
                                },
                                "use_case": {
                                    "type": "string",
                                    "description": "Main use case for the language.",
                                },
                            },
                            "required": [
                                "name",
                                "use_case",
                            ],
                            "additionalProperties": False,
                        },
                        "description": "Three programming languages and their main uses.",
                    },
                },
                "required": [
                    "languages",
                ],
                "additionalProperties": False,
            },
        },
    },
    reasoning={
        "effort": "low",
    },
)

print(response.output_text)

Check that the response completed and did not refuse the request before parsing the JSON. A response that reaches its output-token limit can be incomplete.

Configure reasoning

Set reasoning.effort to select the model’s reasoning effort:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cometapi.com/v1",
    api_key=os.environ["COMETAPI_KEY"],
)

response = client.responses.create(
    model="gpt-6-astra",
    input="Solve this step by step: what is 15% of 240?",
    reasoning={
        "effort": "high",
    },
)

print(response.output_text)

The examples use low for general tasks and high for the reasoning example. max_output_tokens includes both reasoning and visible output tokens.

Stream responses

Set stream to true to receive server-sent events:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cometapi.com/v1",
    api_key=os.environ["COMETAPI_KEY"],
)

stream = client.responses.create(
    model="gpt-6-astra",
    input="Tell me a three sentence bedtime story about a unicorn.",
    reasoning={
        "effort": "low",
    },
    stream=True,
)

for event in stream:
    if event.type == "response.output_text.delta":
        print(event.delta, end="")

A text response includes lifecycle events such as response.created, response.in_progress, and response.completed. Text arrives in response.output_text.delta events. Tool and reasoning events depend on the request, so handle events by their type rather than assuming every response has the same sequence.

See the OpenAI guides for image input, file input, structured outputs, function calling, conversation state, and reasoning.

Authorizations

Authorization

string

header

required

Bearer token authentication. Use your CometAPI key.

Body

application/json

model

string

default:gpt-6-astra

required

Model ID to use for this request. See the Models page for current options.

Example:

"gpt-6-astra"

input

required

Text, image, or file inputs to the model, used to generate a response. Can be a simple string for text-only input, or an array of input items for multimodal content (images, files) and multi-turn conversations.

instructions

string

A system (or developer) message inserted into the model's context. When used with previous_response_id, instructions from the previous response are not carried over — this makes it easy to swap system messages between turns.

background

boolean

Whether to run the model response in the background. Background responses do not return output directly — you retrieve the result later via the response ID.

context_management

object[]

Context management configuration for this request. Controls how the model manages context when the conversation exceeds the context window.

Show child attributes

conversation

The conversation this response belongs to. Items from the conversation are prepended to input for context. Input and output items are automatically added to the conversation after the response completes. Cannot be used with previous_response_id.

include

enum<string>[]

Additional output data to include in the response. Use this to request extra information that is not included by default.

Available options:

web_search_call.action.sources,

code_interpreter_call.outputs,

computer_call_output.output.image_url,

file_search_call.results,

message.input_image.image_url,

message.output_text.logprobs,

reasoning.encrypted_content

max_output_tokens

integer

An upper bound for the number of tokens that can be generated for a response, including visible output tokens and reasoning tokens.

max_tool_calls

integer

The maximum number of total calls to built-in tools that can be processed in a response. This limit applies across all built-in tool calls, not per individual tool. Any further tool call attempts by the model will be ignored.

metadata

object

Set of up to 16 key-value pairs that can be attached to the response. Useful for storing additional information in a structured format. Keys have a maximum length of 64 characters; values have a maximum length of 512 characters.

Show child attributes

parallel_tool_calls

boolean

Whether to allow the model to run tool calls in parallel.

previous_response_id

string

An ID for a stored response that is accessible to the selected model and request context. Cannot be combined with conversation. The conversation-history example sends prior input and output items explicitly.

prompt

object

Reference to a prompt template and its variables.

Show child attributes

prompt_cache_key

string

A key used to cache responses for similar requests, helping optimize cache hit rates. Replaces the deprecated user field for caching purposes.

prompt_cache_retention

enum<string>

deprecated

Legacy prompt-cache retention setting. Refer to the selected model documentation for prompt_cache_options and supported retention settings.

Available options:

in_memory,

24h

reasoning

object

Reasoning configuration for the selected model.

Show child attributes

safety_identifier

string

A stable identifier for your end-users, used to help detect policy violations. Should be a hashed username or email — do not send identifying information directly.

Maximum string length: 64

service_tier

enum<string>

Specifies the processing tier for the request. When set, the response will include the actual service_tier used.

auto: Uses the tier configured in project settings (default behavior).
default: Standard pricing and performance.
flex: Flexible processing with potential cost savings.
priority: Priority processing with faster response times.

Available options:

auto,

default,

flex,

priority

store

boolean

Request response storage for later retrieval, when supported by the selected model and request context.

stream

boolean

If set to true, the response data will be streamed to the client as it is generated using server-sent events (SSE). Events include response.created, response.output_text.delta, response.completed, and more.

stream_options

object

Options for streaming responses. Only set this when stream is true.

Show child attributes

temperature

number

Sampling temperature. Omit this field for GPT-6 Astra.

Required range: 0 <= x <= 2

text

object

Configuration for text output. Use this to request structured JSON output via JSON mode or JSON Schema.

Show child attributes

tool_choice

Controls how the model selects which tool(s) to call.

auto (default): The model decides whether and which tools to call.
none: The model will not call any tools.
required: The model must call at least one tool.
An object specifying a particular tool to use.

tools

object[]

Tools available to the model. This page demonstrates web_search and custom function tools. Other tool types require their own configuration; see the official tool reference.

top_logprobs

integer

Number of token alternatives to include for models supporting log probabilities. Requires message.output_text.logprobs in include. Omit for GPT-6 Astra.

Required range: 0 <= x <= 20

top_p

number

Nucleus sampling threshold. Omit this field for GPT-6 Astra. For sampling overrides, adjust either top_p or temperature.

Required range: 0 <= x <= 1

truncation

enum<string>

The truncation strategy for handling inputs that exceed the model's context window.

auto: The model truncates the input by dropping items from the beginning of the conversation to fit.
disabled (default): The request fails with a 400 error if the input exceeds the context window.

Available options:

auto,

disabled

user

string

deprecated

Deprecated. Use safety_identifier and prompt_cache_key instead. A stable identifier for your end-user.

Response

200 - application/json

The generated Response object.

string

Unique identifier for the response.

Example:

"resp_example"

object

enum<string>

The object type, always response.

Available options:

response

Example:

"response"

created_at

integer

Unix timestamp (in seconds) of when the response was created.

Example:

1788763707

status

enum<string>

The status of the response.

Available options:

completed,

in_progress,

failed,

cancelled,

queued,

incomplete

Example:

"completed"

background

boolean

Whether the response was run in the background.

Example:

false

completed_at

integer | null

Unix timestamp of when the response was completed, or null if still in progress.

Example:

1788763711

error

object | null

Error information if the response failed, or null on success.

Show child attributes

incomplete_details

object | null

Details about why the response is incomplete, if applicable.

Show child attributes

instructions

string | null

The system instructions used for this response.

max_output_tokens

integer | null

The maximum output token limit that was applied.

model

string

The model used for the response.

Example:

"gpt-6-astra"

output

object[]

An array of output items generated by the model. Each item can be a message, function call, or other output type.

Show child attributes

parallel_tool_calls

boolean

Whether parallel tool calls were enabled.

previous_response_id

string | null

The ID of the previous response, if this is a multi-turn conversation.

reasoning

object

The reasoning configuration that was used.

Show child attributes

service_tier

string

The service tier actually used to process the request.

store

boolean

Whether the response was stored.

temperature

number

The temperature value used.

text

object

The text configuration used.

Show child attributes

tool_choice

The tool choice setting used.

tools

object[]

The tools that were available for this response.

top_p

number

The top_p value used.

truncation

string

The truncation strategy used.

usage

object

Token usage statistics for this response.

Show child attributes

user

string | null

The user identifier, if provided.

metadata

object

The metadata attached to this response.

Show child attributes

content_filters

array | null

Content filter results applied to the response, if any.

frequency_penalty

number

The frequency penalty applied to the request.

max_tool_calls

integer | null

Maximum number of tool calls allowed, if set.

presence_penalty

number

The presence penalty applied to the request.

prompt_cache_key

string | null

Cache key for prompt caching, if applicable.

prompt_cache_retention

string | null

Prompt cache retention policy, if applicable.

safety_identifier

string | null

Safety system identifier for the response, if applicable.

top_logprobs

integer

Number of top log probabilities returned per token position.

Last modified on September 7, 2026

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.cometapi.com/v1",
    api_key=os.environ["COMETAPI_KEY"],
)

response = client.responses.create(
    model="gpt-6-astra",
    input="Tell me a three sentence bedtime story about a unicorn.",
    reasoning={
        "effort": "low",
    },
)

print(response.output_text)

{
  "id": "resp_example",
  "object": "response",
  "created_at": 1788763707,
  "status": "completed",
  "background": false,
  "completed_at": 1788763711,
  "error": null,
  "incomplete_details": null,
  "model": "gpt-6-astra",
  "output": [
    {
      "id": "msg_example",
      "type": "message",
      "status": "completed",
      "content": [
        {
          "type": "output_text",
          "annotations": [],
          "logprobs": [],
          "text": "A little unicorn named Luna followed a trail of silver fireflies to a meadow where the flowers chimed softly in the breeze. She curled beneath a willow tree, tucked her hooves into the cool grass, and wished sweet dreams for every creature in the forest. As the moon wrapped the meadow in gentle light, Luna closed her eyes and drifted into dreams of dancing among the stars."
        }
      ],
      "phase": "final_answer",
      "role": "assistant"
    }
  ],
  "parallel_tool_calls": true,
  "previous_response_id": null,
  "reasoning": {
    "context": "all_turns",
    "effort": "low",
    "mode": "standard",
    "summary": null
  },
  "store": true,
  "text": {
    "format": {
      "type": "text"
    },
    "verbosity": "medium"
  },
  "tool_choice": "auto",
  "tools": [],
  "usage": {
    "input_tokens": 17,
    "input_tokens_details": {
      "cache_write_tokens": 0,
      "cached_tokens": 0
    },
    "output_tokens": 81,
    "output_tokens_details": {
      "reasoning_tokens": 0
    },
    "total_tokens": 98
  }
}

Content moderation

API keys

Continue a conversation

Use web search

Call custom functions

Request structured output

Configure reasoning

Stream responses

Authorizations

Body

Response

​Continue a conversation

​Use web search

​Call custom functions

​Request structured output

​Configure reasoning

​Stream responses

Authorizations

Body

Response

Continue a conversation

Use web search

Call custom functions

Request structured output

Configure reasoning

Stream responses