OpenAI Ultrafast 模式

Ultrafast是OpenAI API最快的服务层级，已面向GPT-6 Astra和GPT-6.1 Sol广泛开放，适合速度收益足以抵消较高费用的场景。

建议使用WebSocket，特别是短时间内连续调用工具的智能体应用；没有持久连接时，网络开销会削弱加速效果。

这两个模型的Ultrafast面向所有API用户，配额独立于Standard和Fast。扩流前查看组织限制；有账户团队的组织可联系申请提额。

配置请求

每个response.create事件都设置model为gpt-6-astra或gpt-6.1-sol，并指定service_tier:"ultrafast"：

运行前按建立连接并创建响应安装对应 SDK 和 WebSocket 依赖，并在环境中设置 OPENAI_API_KEY。

来源示例 1（javascript）：

// [中文] 指定受支持模型及service_tier=ultrafast；在同一WebSocket发送两轮请求，用previous_response_id续接。实际层级、限额及费用需核对，未调用API。
// Install: npm install openai ws
// Set OPENAI_API_KEY in your environment.

import OpenAI from "openai";
import { ResponsesWS } from "openai/resources/responses/ws";

const client = new OpenAI();
const ws = new ResponsesWS(client);

let previousResponseId = null;

try {
  for (const input of [
    "Explain why the sky is blue in one sentence.",
    "Now explain why sunsets look red.",
  ]) {
    let completed = false;
    const events = ws.stream();

    ws.send({
      type: "response.create",
      model: "gpt-6-astra",
      service_tier: "ultrafast",
      previous_response_id: previousResponseId,
      input,
    });

    for await (const event of events) {
      if (event.type === "error") throw event.error;
      if (event.type !== "message") continue;
      const message = event.message;
      if (message.type === "response.output_text.delta") {
        process.stdout.write(message.delta);
      } else if (message.type === "response.completed") {
        previousResponseId = message.response.id;
        completed = true;
        console.log();
        break;
      } else if (
        message.type === "response.failed" ||
        message.type === "response.incomplete"
      ) {
        throw new Error(JSON.stringify(message));
      }
    }

    if (!completed) {
      throw new Error("Connection closed before the response finished.");
    }
  }
} finally {
  ws.close();
}

来源示例 2（python）：

## [中文] 指定受支持模型及service_tier=ultrafast；在同一WebSocket发送两轮请求，用previous_response_id续接。实际层级、限额及费用需核对，未调用API。
## Install: pip install --upgrade "openai[realtime]"
## Set OPENAI_API_KEY in your environment.

from openai import OpenAI

client = OpenAI()

previous_response_id: str | None = None
prompts = [
    "Explain why the sky is blue in one sentence.",
    "Now explain why sunsets look red.",
]

with client.responses.connect() as connection:
    for prompt in prompts:
        connection.response.create(
            model="gpt-6-astra",
            service_tier="ultrafast",
            store=False,  # Keep this conversation on the current connection.
            previous_response_id=previous_response_id,
            input=prompt,
        )

        for event in connection:
            if event.type == "response.output_text.delta":
                print(event.delta, end="", flush=True)
            elif event.type == "response.completed":
                previous_response_id = event.response.id
                print()
                break
            elif event.type in {"response.failed", "response.incomplete", "error"}:
                raise RuntimeError(event.to_json())
        else:
            raise RuntimeError("Connection closed before the response finished.")

来源示例 3（go）：

// [中文] 在同一 WebSocket 连接发送两次请求，并在响应完成后输出结果。
package main

import (
    "context"
    "fmt"
    "time"

    "github.com/openai/openai-go/v3"
    "github.com/openai/openai-go/v3/responses"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
    defer cancel()

    client := openai.NewClient()
    conn, err := client.Responses.Connect(ctx, responses.ResponseConnectionOptions{})
    if err != nil {
        panic(err)
    }
    defer conn.Close()

    previousResponseID := ""

    for _, prompt := range []string{
        "Explain why the sky is blue in one sentence.",
        "Now explain why sunsets look red.",
    } {
        request := responses.ResponsesClientEventResponseCreateParam{
            Model:       "gpt-6-astra",
            ServiceTier: "ultrafast",
            Input: responses.ResponsesClientEventResponseCreateInputUnionParam{
                OfString: openai.String(prompt),
            },
        }
        if previousResponseID != "" {
            request.PreviousResponseID = openai.String(previousResponseID)
        }

        if err := conn.Create(ctx, request); err != nil {
            panic(err)
        }

        // FinalResponse reads events until the response finishes.
        response, err := conn.FinalResponse(ctx)
        if err != nil {
            panic(err)
        }
        if response.Status != responses.ResponseStatusCompleted {
            panic(fmt.Sprintf("Response ended with status %s", response.Status))
        }

        previousResponseID = response.ID
        fmt.Println(response.OutputText())
    }
}

来源示例 4（java）：

// [中文] 在同一 WebSocket 连接发送两次请求，并在响应完成后输出结果。
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseStatus;
import com.openai.models.responses.ResponsesClientEvent;
import java.util.List;

var client = OpenAIOkHttpClient.fromEnv();

try (var connection = client.responses().connect()) {
  String previousResponseId = null;

  for (var prompt :
      List.of(
          "Explain why the sky is blue in one sentence.",
          "Now explain why sunsets look red.")) {
    var request =
        ResponsesClientEvent.ResponseCreate.builder()
            .model("gpt-6-astra")
            .serviceTier(ResponsesClientEvent.ResponseCreate.ServiceTier.ULTRAFAST)
            .input(prompt);
    if (previousResponseId != null) {
      request.previousResponseId(previousResponseId);
    }

    connection.send(ResponsesClientEvent.ofResponseCreate(request.build()));

    var response = connection.finalResponse();
    if (response.status().filter(ResponseStatus.COMPLETED::equals).isEmpty()) {
      throw new IllegalStateException(
          "Response ended with status " + response.status().orElse(null));
    }

    previousResponseId = response.id();
    response.output().stream()
        .flatMap(item -> item.message().stream())
        .flatMap(message -> message.content().stream())
        .flatMap(content -> content.outputText().stream())
        .forEach(text -> System.out.println(text.text()));
  }
} finally {
  client.close();
}

来源示例 5（ruby）：

## [中文] 在同一 WebSocket 连接发送两次请求，并在响应完成后输出结果。
## Install: gem install openai async-websocket
## Set OPENAI_API_KEY in your environment.

require "async"
require "openai"

client = OpenAI::Client.new

request = {
  model: "gpt-6-astra",
  service_tier: :ultrafast
}
prompts = [
  "Explain why the sky is blue in one sentence.",
  "Now explain why sunsets look red."
]

Sync do |task|
  task.with_timeout(120) do
    client.responses.connect(request_options: { timeout: 10 }) do |connection|
      prompts.each do |prompt|
        connection.response.create(**request, input: prompt)

        loop do
          event = connection.receive
          raise "Connection closed before the response finished" unless event

          case event
          when OpenAI::Responses::ResponseCompletedEvent
            request[:previous_response_id] = event.response.id
            puts(event.response.output_text)
            break
          when OpenAI::Responses::ResponseFailedEvent, OpenAI::Responses::ResponseIncompleteEvent,
               OpenAI::Responses::ResponsesServerEvent::ResponseWsError
            raise "Response failed: #{event.to_json}"
          end
        end
      end
    end
  end
end

示例在同一连接发送两次请求，并输出每次响应。Go、Java 和 Ruby 示例在收到完整响应后再输出。第二次请求传入新提示词，并将第一次响应的 ID 用作 previous_response_id。后续轮次和工具结果可继续复用连接，见增量输入。

HTTP替代方式

也可通过SDK发HTTP请求；工具调用频繁的智能体仍更适合持久WebSocket以减少请求间开销。

来源示例 6（javascript）：

// [中文] 指定受支持模型及service_tier=ultrafast；HTTP示例等待完整响应；可按需启用流式。实际层级、限额及费用需核对，未调用API。
import OpenAI from "openai";

const client = new OpenAI();

const response = await client.responses.create({
  model: "gpt-6-astra",
  service_tier: "ultrafast",
  input: "Explain why the sky is blue in one sentence.",
});

console.log(response.output_text);

来源示例 7（python）：

## [中文] 指定受支持模型及service_tier=ultrafast；HTTP示例等待完整响应；可按需启用流式。实际层级、限额及费用需核对，未调用API。
from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-6-astra",
    input="Explain why the sky is blue in one sentence.",
    service_tier="ultrafast",
)

print(response.output_text)

来源示例 8（go）：

// [中文] 指定受支持模型及service_tier=ultrafast；HTTP示例等待完整响应；可按需启用流式。实际层级、限额及费用需核对，未调用API。
package main

import (
    "context"
    "fmt"

    "github.com/openai/openai-go/v3"
    "github.com/openai/openai-go/v3/responses"
)

func main() {
    client := openai.NewClient()

    response, err := client.Responses.New(context.Background(), responses.ResponseNewParams{
        Model:       "gpt-6-astra",
        ServiceTier: responses.ResponseNewParamsServiceTierUltrafast,
        Input:       responses.ResponseNewParamsInputUnion{OfString: openai.String("Explain why the sky is blue in one sentence.")},
    })
    if err != nil {
        panic(err)
    }

    fmt.Println(response.OutputText())
}

来源示例 9（java）：

// [中文] 指定受支持模型及service_tier=ultrafast；HTTP示例等待完整响应；可按需启用流式。实际层级、限额及费用需核对，未调用API。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.responses.ResponseCreateParams;

ResponseCreateParams params =
    ResponseCreateParams.builder()
        .model("gpt-6-astra")
        .input("Explain why the sky is blue in one sentence.")
        .serviceTier(ResponseCreateParams.ServiceTier.ULTRAFAST)
        .build();

client.responses().create(params).output().stream()
    .flatMap(item -> item.message().stream())
    .flatMap(message -> message.content().stream())
    .flatMap(content -> content.outputText().stream())
    .forEach(text -> System.out.println(text.text()));

来源示例 10（ruby）：

## [中文] 指定受支持模型及service_tier=ultrafast；HTTP示例等待完整响应；可按需启用流式。实际层级、限额及费用需核对，未调用API。
require "openai"

client = OpenAI::Client.new

response = client.responses.create(
  model: "gpt-6-astra",
  service_tier: :ultrafast,
  input: "Explain why the sky is blue in one sentence."
)

puts(response.output_text)

来源示例 11（bash）：

## [中文] 指定受支持模型及service_tier=ultrafast；HTTP示例等待完整响应；可按需启用流式。实际层级、限额及费用需核对，未调用API。
curl https://api.openai.com/v1/responses \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "input": "Explain why the sky is blue in one sentence.",
    "service_tier": "ultrafast"
  }'

该示例等待完整响应。需要边生成边展示时，可开启流式输出。

可用性

来源列出的GPT-6.1 Sol默认Ultrafast TPM如下：

GPT-6 Astra默认值：

输入、缓存输入、缓存写入及输出价格见Ultrafast价格表。GPT-6.1 Sol支持美国和欧盟数据驻留及全球处理；GPT-6 Astra Ultrafast仅支持美国数据驻留及全球处理。实际账户限制和资格仍需确认。