Short answer: Build a new GPT-6 Astra integration around the Responses API and the model ID gpt-6-astra. The current OpenAI guidance documents structured outputs, streaming, asynchronous tool calling, mid-turn steering, prompt caching, persisted reasoning and compaction. Keep tool execution on your server, validate every argument, and log the model, response ID, tool call ID and policy decision. This guide shows the documented request and tool-loop shape; the snippets are documentation-aligned examples, not live-test evidence.
This is the code-first guide. The GPT-6 Astra launch overview covers rollout and product boundaries, the migration checklist covers an existing application, and the Astra pricing guide covers token arithmetic.
Use the current Responses API shape
OpenAI’s Responses migration guide uses client.responses.create, a model ID, instructions and input. The current Astra model page documents a 1,050,000-token context window, up to 128,000 output tokens, text and image input, and reasoning settings from low through max. Do not assume that a GPT-5.6 request helper is compatible: Astra’s current guidance calls out legacy sampling and log-probability fields for removal or rechecking.
Minimal Python request
from openai import OpenAI
client = OpenAI()
response = client.responses.create(
model="gpt-6-astra",
instructions="You are a helpful assistant.",
input="Hello!",
)
print(response.output_text)Minimal JavaScript request
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.OPENAI_API_KEY,
});
const response = await client.responses.create({
model: "gpt-6-astra",
instructions: "You are a helpful assistant.",
input: "Hello!",
});
console.log(response.output_text);The examples follow the current OpenAI documentation. Install the official SDK from the libraries page, load the key from the environment and never place it in browser code. A production wrapper should also record request status, latency, usage and error class without storing sensitive prompt content by default.
Define a strict tool contract
Responses tool calling is a loop: send a function schema, preserve the model output, execute the requested function in your application, append a function_call_output with the original call_id, and ask the model to continue. The model proposes arguments; it does not grant permission to perform the action.
from openai import OpenAI
import json
client = OpenAI()
tools = [{
"type": "function",
"name": "get_horoscope",
"description": "Get today's horoscope for an astrological sign.",
"parameters": {
"type": "object",
"properties": {
"sign": {
"type": "string",
"description": "A zodiac sign, for example Aries."
}
},
"required": ["sign"],
"additionalProperties": False
},
"strict": True
}]
def get_horoscope(sign):
# Replace with a validated, authorized application function.
return sign + ": Keep the plan small and measurable."
input_items = [{
"role": "user",
"content": "What is today's horoscope for Aries?"
}]
response = client.responses.create(
model="gpt-6-astra",
tools=tools,
input=input_items
)
input_items += response.output
for item in response.output:
if item.type == "function_call":
args = json.loads(item.arguments)
result = get_horoscope(args["sign"])
input_items.append({
"type": "function_call_output",
"call_id": item.call_id,
"output": result
})
response = client.responses.create(
model="gpt-6-astra",
instructions="Answer using the tool result. Do not invent a horoscope.",
tools=tools,
input=input_items
)
print(response.output_text)The schema is intentionally strict: the function name, required field and additional-property rule are part of the application contract. In a real tool, validate the enum or allowed values again in get_horoscope; schema validation is not authorization.
The equivalent JavaScript loop
import OpenAI from "openai";
const openai = new OpenAI();
/** @type {OpenAI.Responses.Tool[]} */
const tools = [{
type: "function",
name: "get_horoscope",
description: "Get today's horoscope for an astrological sign.",
parameters: {
type: "object",
properties: {
sign: {
type: "string",
description: "A zodiac sign, for example Aries."
}
},
required: ["sign"],
additionalProperties: false
},
strict: true
}];
function getHoroscope(sign) {
return sign + ": Keep the plan small and measurable.";
}
let input = [{
role: "user",
content: "What is today's horoscope for Aries?"
}];
let response = await openai.responses.create({
model: "gpt-6-astra",
tools,
input
});
input.push(...response.output);
for (const item of response.output) {
if (item.type !== "function_call") continue;
const args = JSON.parse(item.arguments);
input.push({
type: "function_call_output",
call_id: item.call_id,
output: getHoroscope(args.sign)
});
}
response = await openai.responses.create({
model: "gpt-6-astra",
instructions: "Answer using the tool result. Do not invent a horoscope.",
tools,
input
});
console.log(response.output_text);A typical intermediate result is a response output item with type: "function_call", a tool name, JSON arguments and a provider-generated call_id. Your application should append the matching function_call_output; do not create a new ID or join results by array position. The final response can contain natural-language text, structured output or another tool call.
Make the loop safe to retry
- Authorization: map the signed-in principal to an allowlist of tools and scopes before execution.
- Validation: parse JSON, validate types and ranges, and reject unknown arguments.
- Idempotency: attach a request key to writes so a timeout cannot duplicate an external action.
- Confirmation: require a human confirmation for payment, deletion, publication, account changes or irreversible messages.
- Traceability: store response ID, call ID, tool version, policy result, result hash and reviewer decision.
- Recovery: cap turns and retries, expose cancellation, and keep a read-only fallback.
Async tools, steering and parameter checks
OpenAI’s Astra guidance documents asynchronous tool calling and mid-turn steering. Treat an asynchronous run as durable state: persist the response ID and call ID, verify that the returning result belongs to the same principal and request, then resume only if the policy is still valid. For long jobs, add a timeout, cancellation state and a dead-letter path.
Reasoning levels are low through max; there is no documented none setting for Astra. Test the lowest setting that clears your acceptance bar instead of defaulting to max. Remove or recheck temperature, top_p, top_logprobs, logprobs and other legacy sampling controls called out in the migration guidance. Keep a contract test that fails when a shared helper reintroduces a retired field.
Budget and context before production
The current Astra model page lists $10 per million input tokens, $1 cached input, $12.50 cache writes and $50 output. Requests above 272,000 input tokens receive 2× input/cache and 1.5× output pricing for the full request. Batch and Flex are listed at 50% of standard rates; Fast is 2× applicable rates where available. The pricing article works through those examples. If EU data residency matters, check the current guidance because Fast is unavailable with EU data residency.
Test without pretending the live call happened
These examples follow the documented SDK patterns and have not been execution-tested against a live API. Before release, run them in an organization that has access, with a test key and a non-sensitive fixture. Record the SDK version, model ID, endpoint, request schema, response event types, tool-call arguments, latency, input/output usage, retries and final output. Test malformed JSON, a denied tool, duplicate delivery, timeout, cancellation, prompt injection in tool results and a model response that asks for a tool your principal cannot use.
Frequently asked questions
Should every Astra integration use Responses?
For new tool-oriented work, the current OpenAI migration and latest-model guidance point to Responses. Confirm the endpoint and compatibility requirements for an existing product before changing its transport.
Can the model execute my function?
No. Astra can return a function call; your server decides whether to execute it, with its own authorization, validation and confirmation boundaries.
How do I choose between Astra and GPT-5.6?
Run a fixed representative set. A cheaper GPT-5.6 Sol, Terra or Luna route may win when the task is routine, high volume or mechanically validated. See the GPT-5.6 model-selection guide and the older-model comparison.
Bottom line
Use the documented Responses shape, pass a strict tool schema, preserve output items and call IDs, validate every tool result and measure an acceptance bar before expanding access. The code is a starting point for a controlled implementation; it is not evidence that a live request succeeded.
See OpenAI’s Responses guide and function-calling guide for the current API shape. These examples have not been execution-tested against a live API.
