OpenAI Chat Completions 中的音频

如果已有使用 Chat Completions 端点的文本大语言模型应用，可以为其增加音频能力。例如，聊天应用原本支持文本输入，要加入音频输入和输出，可在 modalities 数组中包含 audio，并使用 gpt-audio-1.5 等音频模型。

Responses API 文档当前描述的是文本、图像输入和文本输出。对于这里的音频聊天模式，请使用 Chat Completions 和支持音频的模型。

模型输出音频：根据提示生成类似人声的音频回复。

来源示例 1（javascript）：

程序文字译释1：金毛寻回犬适合作为家庭犬吗？

// [中文] 示例 1：Chat Completions 中的音频；以下保留本语言原始示例。
// [中文] 原代码明确设置的模型值：gpt-audio-1.5；各值的作用按其所在配置对象区分。
// [中文] 将 Base64 载荷解码成原始字节；字节后续写文件、缓冲或播放的位置按本例处理。
import { writeFileSync } from "node:fs";
import OpenAI from "openai";

const openai = new OpenAI();

// Generate an audio response to the given prompt
const response = await openai.chat.completions.create({
  model: "gpt-audio-1.5",
  modalities: ["text", "audio"],
  audio: { voice: "alloy", format: "wav" },
  messages: [
    {
      role: "user",
      content: "Is a golden retriever a good family dog?",
    },
  ],
  store: true,
});

// Inspect returned data
console.log(response.choices[0]);

// Write audio data to a file
writeFileSync(
  "dog.wav",
  Buffer.from(response.choices[0].message.audio.data, "base64"),
  { encoding: "utf-8" }
);

来源示例 2（python）：

沿用程序文字译释1。

## [中文] 示例 2：Chat Completions 中的音频；以下保留本语言原始示例。
## [中文] 原代码明确设置的模型值：gpt-audio-1.5；各值的作用按其所在配置对象区分。
## [中文] 沿原示例执行这些方法：client.chat.completions.create；异步调用及事件接收顺序保留。
## [中文] 将 Base64 载荷解码成原始字节；字节后续写文件、缓冲或播放的位置按本例处理。
import base64
from openai import OpenAI

client = OpenAI()

completion = client.chat.completions.create(
    model="gpt-audio-1.5",
    modalities=["text", "audio"],
    audio={"voice": "alloy", "format": "wav"},
    messages=[{"role": "user", "content": "Is a golden retriever a good family dog?"}],
)

print(completion.choices[0])

wav_bytes = base64.b64decode(completion.choices[0].message.audio.data)
with open("dog.wav", "wb") as f:
    f.write(wav_bytes)

来源示例 3（go）：

沿用程序文字译释1。

// [中文] 示例 3：Chat Completions 中的音频；以下保留本语言原始示例。
// [中文] 原代码明确设置的模型值：gpt-audio-1.5；各值的作用按其所在配置对象区分。
// [中文] 沿原示例执行这些方法：client.Chat.Completions.New；异步调用及事件接收顺序保留。
// [中文] 将 Base64 载荷解码成原始字节；字节后续写文件、缓冲或播放的位置按本例处理。
package main

import (
    "context"
    "encoding/base64"
    "fmt"
    "os"

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

func main() {
    client := openai.NewClient()
    response, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
        Model:      "gpt-audio-1.5",
        Modalities: []string{"text", "audio"},
        Audio: openai.ChatCompletionAudioParam{
            Voice:  openai.ChatCompletionAudioParamVoiceUnion{OfString: openai.String("alloy")},
            Format: openai.ChatCompletionAudioParamFormatWAV,
        },
        Messages: []openai.ChatCompletionMessageParamUnion{openai.UserMessage("Is a golden retriever a good family dog?")},
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(response.Choices[0])
    audio, err := base64.StdEncoding.DecodeString(response.Choices[0].Message.Audio.Data)
    if err != nil {
        panic(err)
    }
    if err := os.WriteFile("dog.wav", audio, 0o600); err != nil {
        panic(err)
    }
}

来源示例 4（java）：

沿用程序文字译释1。

程序文字译释2：未返回音频输出。

// [中文] 保留原例中客户端、输入和返回值的处理顺序；本段需结合所在小节的连接前提使用，未通过真实API调用验证。
// [中文] 本段为配置或调用片段，需结合外层程序与已建立连接使用；不作为独立完整程序宣称编译通过。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionAudioParam;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-audio-1.5")
        .addUserMessage("Is a golden retriever a good family dog?")
        .addModality(ChatCompletionCreateParams.Modality.TEXT)
        .addModality(ChatCompletionCreateParams.Modality.AUDIO)
        .audio(
            ChatCompletionAudioParam.builder()
                .voice("alloy")
                .format(ChatCompletionAudioParam.Format.WAV)
                .build())
        .store(false)
        .build();

var message = client.chat().completions().create(params).choices().get(0).message();
var audio =
    message.audio().orElseThrow(() -> new IllegalStateException("No audio output returned"));
Files.write(Path.of("dog.wav"), Base64.getDecoder().decode(audio.data()));
message.content().ifPresent(System.out::println);

来源示例 5（csharp）：

沿用程序文字译释1。

程序文字译释3：没有返回音频输出。

// [中文] 保留原例中客户端、输入和返回值的处理顺序；本段需结合所在小节的连接前提使用，未通过真实API调用验证。
using OpenAI.Chat;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ChatClient client = new("gpt-audio-1.5", key);

ChatCompletionOptions options = new()
{
    ResponseModalities = ChatResponseModalities.Text | ChatResponseModalities.Audio,
    AudioOptions = new(ChatOutputAudioVoice.Alloy, ChatOutputAudioFormat.Wav),
    StoredOutputEnabled = false,
};

ChatCompletion completion = await client.CompleteChatAsync(
    [new UserChatMessage("Is a golden retriever a good family dog?")],
    options
);

if (completion.OutputAudio is not ChatOutputAudio audio)
{
    throw new InvalidOperationException("No audio output was returned.");
}

Console.WriteLine(audio.Transcript);
await File.WriteAllBytesAsync("dog.wav", audio.AudioBytes.ToArray());

来源示例 6（ruby）：

沿用程序文字译释1。

程序文字译释4：未返回音频。

## [中文] 示例 6：Chat Completions 中的音频；以下保留本语言原始示例。
## [中文] 原代码明确设置的模型值：gpt-audio-1.5；各值的作用按其所在配置对象区分。
## [中文] 沿原示例执行这些方法：client.chat.completions.create；异步调用及事件接收顺序保留。
## [中文] 将 Base64 载荷解码成原始字节；字节后续写文件、缓冲或播放的位置按本例处理。
require "base64"
require "openai"

client = OpenAI::Client.new
completion = client.chat.completions.create(
  model: "gpt-audio-1.5",
  messages: [
    {
      role: :user,
      content: "Is a golden retriever a good family dog?"
    }
  ],
  modalities: [:text, :audio],
  audio: {
    voice: :alloy,
    format: :wav
  },
  store: true
)

audio = completion.choices.fetch(0).message.audio or raise "No audio returned"
File.binwrite("dog.wav", Base64.strict_decode64(audio.data))

来源示例 7（bash）：

程序文字译释5：用户问题：金毛寻回犬适合作为家庭犬吗？其余字段为音频模型、文本与音频模态、声音和WAV格式配置，字段值保留原样。

## [中文] 示例 7：Chat Completions 中的音频；以下保留本语言原始示例。
## [中文] 本段涉及的 HTTP 端点：/v1/chat/completions；认证和请求体保持原示例形式。
curl "https://api.openai.com/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
      "model": "gpt-audio-1.5",
      "modalities": ["text", "audio"],
      "audio": { "voice": "alloy", "format": "wav" },
      "messages": [
        {
          "role": "user",
          "content": "Is a golden retriever a good family dog?"
        }
      ]
    }'

向模型输入音频：使用音频输入向模型提供提示。

来源示例 8（javascript）：

程序文字译释6：这段录音中有什么？

// [中文] 保留原例中客户端、输入和返回值的处理顺序；本段需结合所在小节的连接前提使用，未通过真实API调用验证。
import OpenAI from "openai";
const openai = new OpenAI();

// Fetch an audio file and convert it to a base64 string
const url = "https://cdn.openai.com/API/docs/audio/alloy.wav";
const audioResponse = await fetch(url);
const buffer = await audioResponse.arrayBuffer();
const base64str = Buffer.from(buffer).toString("base64");

const response = await openai.chat.completions.create({
  model: "gpt-audio-1.5",
  modalities: ["text", "audio"],
  audio: { voice: "alloy", format: "wav" },
  messages: [
    {
      role: "user",
      content: [
        { type: "text", text: "What is in this recording?" },
        {
          type: "input_audio",
          input_audio: { data: base64str, format: "wav" },
        },
      ],
    },
  ],
  store: false,
});

console.log(response.choices[0]);

来源示例 9（python）：

沿用程序文字译释6。

## [中文] 按原代码构造或处理这些事件：text、input_audio；保留请求与服务端确认的区别。
import base64
import requests
from openai import OpenAI

client = OpenAI()

## Fetch the audio file and convert it to a base64 encoded string
url = "https://cdn.openai.com/API/docs/audio/alloy.wav"
response = requests.get(url)
response.raise_for_status()
wav_data = response.content
encoded_string = base64.b64encode(wav_data).decode("utf-8")

completion = client.chat.completions.create(
    model="gpt-audio-1.5",
    store=False,
    modalities=["text", "audio"],
    audio={"voice": "alloy", "format": "wav"},
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "What is in this recording?"},
                {
                    "type": "input_audio",
                    "input_audio": {"data": encoded_string, "format": "wav"},
                },
            ],
        },
    ],
)

print(completion.choices[0].message)

来源示例 10（go）：

沿用程序文字译释6。

// [中文] 示例 10：Chat Completions 中的音频；以下保留本语言原始示例。
// [中文] 原代码明确设置的模型值：gpt-audio-1.5；各值的作用按其所在配置对象区分。
// [中文] 沿原示例执行这些方法：client.Chat.Completions.New；异步调用及事件接收顺序保留。
// [中文] 需要发送的原始字节先编码为 Base64；编码不会替代重采样或改变编解码格式。
package main

import (
    "context"
    "encoding/base64"
    "fmt"
    "os"

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

func main() {
    audio, err := os.ReadFile("fixtures/audio.wav")
    if err != nil {
        panic(err)
    }
    client := openai.NewClient()
    response, err := client.Chat.Completions.New(context.Background(), openai.ChatCompletionNewParams{
        Model:      "gpt-audio-1.5",
        Modalities: []string{"text", "audio"},
        Audio: openai.ChatCompletionAudioParam{
            Voice:  openai.ChatCompletionAudioParamVoiceUnion{OfString: openai.String("alloy")},
            Format: openai.ChatCompletionAudioParamFormatWAV,
        },
        Messages: []openai.ChatCompletionMessageParamUnion{openai.UserMessage([]openai.ChatCompletionContentPartUnionParam{
            openai.TextContentPart("What is in this recording?"),
            openai.InputAudioContentPart(openai.ChatCompletionContentPartInputAudioInputAudioParam{
                Data:   base64.StdEncoding.EncodeToString(audio),
                Format: "wav",
            }),
        })},
    })
    if err != nil {
        panic(err)
    }
    fmt.Println(response.Choices[0])
}

来源示例 11（java）：

沿用程序文字译释6。

// [中文] 保留原例中客户端、输入和返回值的处理顺序；本段需结合所在小节的连接前提使用，未通过真实API调用验证。
// [中文] 本段为配置或调用片段，需结合外层程序与已建立连接使用；不作为独立完整程序宣称编译通过。
import com.openai.client.OpenAIClient;
import com.openai.client.okhttp.OpenAIOkHttpClient;
import com.openai.models.chat.completions.ChatCompletionAudioParam;
import com.openai.models.chat.completions.ChatCompletionContentPart;
import com.openai.models.chat.completions.ChatCompletionContentPartInputAudio;
import com.openai.models.chat.completions.ChatCompletionContentPartText;
import com.openai.models.chat.completions.ChatCompletionCreateParams;
import com.openai.models.chat.completions.ChatCompletionUserMessageParam;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Base64;
import java.util.List;

String encodedAudio =
    Base64.getEncoder()
        .encodeToString(
            Files.readAllBytes(Path.of(System.getenv("OPENAI_EXAMPLE_AUDIO_PATH"))));

ChatCompletionCreateParams params =
    ChatCompletionCreateParams.builder()
        .model("gpt-audio-1.5")
        .addMessage(
            ChatCompletionUserMessageParam.builder()
                .contentOfArrayOfContentParts(
                    List.of(
                        ChatCompletionContentPart.ofText(
                            ChatCompletionContentPartText.builder()
                                .text("What is in this recording?")
                                .build()),
                        ChatCompletionContentPart.ofInputAudio(
                            ChatCompletionContentPartInputAudio.builder()
                                .inputAudio(
                                    ChatCompletionContentPartInputAudio.InputAudio.builder()
                                        .data(encodedAudio)
                                        .format(
                                            ChatCompletionContentPartInputAudio.InputAudio
                                                .Format.WAV)
                                        .build())
                                .build())))
                .build())
        .addModality(ChatCompletionCreateParams.Modality.TEXT)
        .addModality(ChatCompletionCreateParams.Modality.AUDIO)
        .audio(
            ChatCompletionAudioParam.builder()
                .voice("alloy")
                .format(ChatCompletionAudioParam.Format.WAV)
                .build())
        .store(false)
        .build();

client.chat().completions().create(params).choices().stream()
    .flatMap(choice -> choice.message().content().stream())
    .forEach(System.out::println);

来源示例 12（csharp）：

沿用程序文字译释3。

沿用程序文字译释6。

// [中文] 保留原例中客户端、输入和返回值的处理顺序；本段需结合所在小节的连接前提使用，未通过真实API调用验证。
using OpenAI.Chat;
#pragma warning disable OPENAI001

string key = Environment.GetEnvironmentVariable("OPENAI_API_KEY")!;
ChatClient client = new("gpt-audio-1.5", key);

BinaryData audio = BinaryData.FromBytes(
    await File.ReadAllBytesAsync("audio.wav")
);
UserChatMessage message = new(
    [
        ChatMessageContentPart.CreateTextPart("What is in this recording?"),
        ChatMessageContentPart.CreateInputAudioPart(
            audio,
            ChatInputAudioFormat.Wav
        ),
    ]
);
ChatCompletionOptions options = new()
{
    ResponseModalities = ChatResponseModalities.Text | ChatResponseModalities.Audio,
    AudioOptions = new(ChatOutputAudioVoice.Alloy, ChatOutputAudioFormat.Wav),
    StoredOutputEnabled = false,
};

ChatCompletion completion = await client.CompleteChatAsync([message], options);

if (completion.OutputAudio is not ChatOutputAudio audioOutput)
{
    throw new InvalidOperationException("No audio output was returned.");
}

Console.WriteLine(audioOutput.Transcript);

来源示例 13（ruby）：

沿用程序文字译释6。

## [中文] 保留原例中客户端、输入和返回值的处理顺序；本段需结合所在小节的连接前提使用，未通过真实API调用验证。
require "base64"
require "openai"

client = OpenAI::Client.new
audio = Base64.strict_encode64(File.binread("audio.wav"))
completion = client.chat.completions.create(
  model: "gpt-audio-1.5",
  messages: [
    {
      role: :user,
      content: [
        {
          type: :text,
          text: "What is in this recording?"
        },
        {
          type: :input_audio,
          input_audio: {
            data: audio,
            format: :wav
          }
        }
      ]
    }
  ],
  modalities: [:text, :audio],
  audio: {
    voice: :alloy,
    format: :wav
  },
  store: false
)

message = completion.choices.fetch(0).message
puts(message.audio&.transcript || message.content)

来源示例 14（bash）：

程序文字译释7：用户问题：这段录音中有什么？input_audio提供Base64编码的WAV输入；占位符应替换为实际音频字节。

## [中文] 示例 14：Chat Completions 中的音频；以下保留本语言原始示例。
## [中文] 本段涉及的 HTTP 端点：/v1/chat/completions；认证和请求体保持原示例形式。
curl "https://api.openai.com/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $OPENAI_API_KEY" \
    -d '{
      "model": "gpt-audio-1.5",
      "modalities": ["text", "audio"],
      "audio": { "voice": "alloy", "format": "wav" },
      "messages": [
        {
          "role": "user",
          "content": [
            { "type": "text", "text": "What is in this recording?" },
            { 
              "type": "input_audio", 
              "input_audio": { 
                "data": "<base64 bytes here>", 
                "format": "wav" 
              }
            }
          ]
        }
      ]
    }'