Conversas com a Realtime API

Depois de se conectar à Realtime API via WebRTC ou WebSocket, você pode chamar um modelo Realtime (como gpt-realtime-2.1) para ter conversas de fala para fala. Para isso, você precisa enviar eventos do cliente para iniciar ações e escutar eventos do servidor para reagir às ações da Realtime API.

Este guia explica como acompanhar o estado de uma sessão Realtime e quais fluxos de eventos usar para acessar recursos do modelo, como geração de áudio e texto, entrada de imagens e chamada de função.

Se você não precisa conversar com o modelo, ou seja, não espera uma resposta, pode usar a Realtime API no modo de transcrição.

Sessões Realtime de fala para fala

Uma sessão Realtime é uma interação que mantém o estado entre o modelo e um cliente conectado. A sessão tem três componentes principais.

O objeto Sessão controla os parâmetros da interação, como o modelo, a voz usada para gerar o áudio de saída e outras configurações.
A Conversa representa os itens de entrada do usuário e os itens de saída que o modelo gera durante a sessão atual.
As Respostas são itens de áudio ou texto que o modelo gera e que passam a fazer parte da conversa.

Buffer de áudio de entrada e WebSockets

Se você usa WebRTC, as APIs do WebRTC cuidam de boa parte do processamento de mídia necessário para enviar áudio ao modelo e receber áudio dele.

Se você usa WebSockets para transmitir áudio, precisa interagir manualmente com o buffer de áudio de entrada. Para isso, envie o áudio codificado em Base64 ao servidor em eventos JSON.

Juntos, esses componentes formam uma sessão Realtime. Use eventos do cliente para atualizar o estado da sessão e escute eventos do servidor para reagir às mudanças de estado.

Diagrama do estado de uma sessão Realtime

Eventos do ciclo de vida da sessão

Depois que você inicia uma sessão via WebRTC ou WebSockets, o servidor envia um evento session.created para indicar que a sessão está pronta. No cliente, você pode atualizar a configuração da sessão atual com o evento session.update. A maioria das propriedades da sessão pode ser atualizada a qualquer momento. A exceção é a propriedade voice, que define a voz da saída de áudio e só pode ser alterada até que o modelo responda com áudio pela primeira vez na sessão. Uma sessão Realtime pode durar até 60 minutos.

O exemplo a seguir atualiza a sessão com um evento session.update do cliente. Consulte o guia de WebRTC ou o de WebSocket para saber mais sobre o envio de eventos do cliente por esses canais.

Atualize as instruções de sistema que o modelo usa nesta sessão

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41const event = {
  type: "session.update",
  session: {
    type: "realtime",
    model: "gpt-realtime-2.1",
    // Lock the output to audio (set to ["text"] if you want text without audio)
    output_modalities: ["audio"],
    audio: {
      input: {
        format: {
          type: "audio/pcm",
          rate: 24000,
        },
        turn_detection: {
          type: "semantic_vad",
        },
      },
      output: {
        format: {
          type: "audio/pcm",
          rate: 24000,
        },
        voice: "marin",
      },
    },
    // Use a server-stored prompt by ID. Optionally pin a version and pass variables.
    prompt: {
      id: "pmpt_123", // your stored prompt ID
      version: "89", // optional: pin a specific version
      variables: {
        city: "Paris", // example variable used by your prompt
      },
    },
    // You can still set direct session fields; these override prompt fields if they overlap:
    instructions:
      "Speak clearly and briefly. Confirm understanding before taking actions.",
  },
};

// WebRTC data channel and WebSocket both have .send()
dataChannel.send(JSON.stringify(event));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35event = {
    "type": "session.update",
    "session": {
        "type": "realtime",
        "model": "gpt-realtime-2.1",
        # Choose ["audio"] or ["text"]; do not combine them.
        "output_modalities": ["audio"],
        "audio": {
            "input": {
                "format": {
                    "type": "audio/pcm",
                    "rate": 24000,
                },
                "turn_detection": {"type": "semantic_vad"},
            },
            "output": {
                "format": {
                    "type": "audio/pcmu",
                },
                "voice": "marin",
            },
        },
        # Use a server-stored prompt by ID. Optionally pin a version and pass variables.
        "prompt": {
            "id": "pmpt_123",  # Your stored prompt ID.
            "version": "89",  # Optional: pin a specific version.
            "variables": {
                "city": "Paris",  # Example variable used by your prompt.
            },
        },
        # Direct session fields override prompt fields if they overlap.
        "instructions": "Speak clearly and briefly. Confirm understanding before taking actions.",
    },
}
ws.send(json.dumps(event))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40// Replace pmpt_123 and 89 with an existing saved prompt and version.
// The saved prompt must define the city variable.
if err := conn.Send(ctx, realtime.RealtimeClientEventParamOfSessionUpdate(realtime.RealtimeSessionCreateRequestParam{
	Model: "gpt-realtime-2.1",
	Prompt: responses.ResponsePromptParam{
		ID:      "pmpt_123",
		Version: openai.String("89"),
		Variables: map[string]responses.ResponsePromptVariableUnionParam{
			"city": {
				OfString: openai.String("Paris"),
			},
		},
	},
	OutputModalities: []string{"audio"},
	Instructions:     openai.String("Speak clearly and briefly. Confirm before taking action."),
	Audio: realtime.RealtimeAudioConfigParam{
		Input: realtime.RealtimeAudioConfigInputParam{
			Format: realtime.RealtimeAudioFormatsUnionParam{
				OfAudioPCM: &realtime.RealtimeAudioFormatsAudioPCMParam{
					Rate: 24000,
				},
			},
			TurnDetection: realtime.RealtimeAudioInputTurnDetectionUnionParam{
				OfSemanticVad: &realtime.RealtimeAudioInputTurnDetectionSemanticVadParam{},
			},
		},
		Output: realtime.RealtimeAudioConfigOutputParam{
			Format: realtime.RealtimeAudioFormatsUnionParam{
				OfAudioPCM: &realtime.RealtimeAudioFormatsAudioPCMParam{
					Rate: 24000,
				},
			},
			Voice: realtime.RealtimeAudioConfigOutputVoiceUnionParam{
				OfString: openai.String("marin"),
			},
		},
	},
})); err != nil {
	return err
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48import com.openai.client.okhttp.OkHttpClient;
import com.openai.core.ClientOptions;
import com.openai.core.JsonValue;
import com.openai.helpers.RealtimeConnection;
import com.openai.helpers.RealtimeWebSocketOptions;
import com.openai.models.realtime.*;

// Replace pmpt_123 with your stored prompt ID.
var pcm =
    RealtimeAudioFormats.AudioPcm.builder()
        .type(RealtimeAudioFormats.AudioPcm.Type.AUDIO_PCM)
        .rate(RealtimeAudioFormats.AudioPcm.Rate._24000)
        .build();
connection.send(
    RealtimeClientEvent.ofSessionUpdate(
        SessionUpdateEvent.builder()
            .session(
                RealtimeSessionCreateRequest.builder()
                    .model("gpt-realtime-2.1")
                    .addOutputModality(RealtimeSessionCreateRequest.OutputModality.AUDIO)
                    .audio(
                        RealtimeAudioConfig.builder()
                            .input(
                                RealtimeAudioConfigInput.builder()
                                    .format(pcm)
                                    .turnDetection(
                                        RealtimeAudioInputTurnDetection.SemanticVad.builder()
                                            .build())
                                    .build())
                            .output(
                                RealtimeAudioConfigOutput.builder()
                                    .format(pcm)
                                    .voice("marin")
                                    .build())
                            .build())
                    .prompt(
                        com.openai.models.responses.ResponsePrompt.builder()
                            .id("pmpt_123")
                            .version("89")
                            .variables(
                                com.openai.models.responses.ResponsePrompt.Variables.builder()
                                    .putAdditionalProperty("city", JsonValue.from("Paris"))
                                    .build())
                            .build())
                    .instructions(
                        "Speak clearly and briefly. Confirm understanding before taking actions.")
                    .build())
            .build()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28# Replace the illustrative IDs and URLs below with your own resource values.
connection.session.update(
  type: :realtime,
  model: "gpt-realtime-2.1",
  output_modalities: [:audio],
  audio: {
    input: {
      format: {
        type: :"audio/pcm",
        rate: 24_000
      },
      turn_detection: { type: :semantic_vad }
    },
    output: {
      format: {
        type: :"audio/pcm",
        rate: 24_000
      },
      voice: :marin
    }
  },
  prompt: {
    id: "pmpt_123",
    version: "89",
    variables: { city: "Paris" }
  },
  instructions: "Speak clearly and briefly. Confirm before taking action."
)

Após a atualização, o servidor emite um evento session.updated com o novo estado da sessão.

Eventos relacionados do cliente Eventos relacionados do servidor

Eventos relacionados do cliente	Eventos relacionados do servidor
`session.update`	`session.created` `session.updated`

session.update

session.created

session.updated

Entradas e saídas de texto

Para gerar texto com um modelo Realtime, adicione entradas de texto à conversa atual, peça ao modelo que gere uma resposta e escute os eventos que o servidor envia para indicar o progresso da resposta. A geração de texto exige que você configure a sessão com a modalidade text, que já vem habilitada por padrão.

Crie um item de texto na conversa com o evento conversation.item.create do cliente. Isso é semelhante a enviar uma mensagem do usuário (prompt) em Chat Completions pela API REST.

Crie um item na conversa com a entrada do usuário

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16const event = {
  type: "conversation.item.create",
  item: {
    type: "message",
    role: "user",
    content: [
      {
        type: "input_text",
        text: "What Prince album sold the most copies?",
      },
    ],
  },
};

// WebRTC data channel and WebSocket both have .send()
ws.send(JSON.stringify(event));

1
2
3
4
5
6
7
8
9
10
11
12
13
14event = {
    "type": "conversation.item.create",
    "item": {
        "type": "message",
        "role": "user",
        "content": [
            {
                "type": "input_text",
                "text": "What Prince album sold the most copies?",
            }
        ],
    },
}
ws.send(json.dumps(event))

1
2
3
4
5
6
7
8
9
10if err := conn.Send(ctx, realtime.RealtimeClientEventParamOfConversationItemCreate(realtime.RealtimeConversationItemUserMessageParam{
	Content: []realtime.RealtimeConversationItemUserMessageContentParam{
		{
			Text: openai.String("What Prince album sold the most copies?"),
			Type: "input_text",
		},
	},
})); err != nil {
	return err
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import com.openai.client.okhttp.OkHttpClient;
import com.openai.core.ClientOptions;
import com.openai.core.JsonMissing;
import com.openai.helpers.RealtimeConnection;
import com.openai.helpers.RealtimeWebSocketOptions;
import com.openai.models.realtime.*;

connection.send(
    RealtimeClientEvent.ofConversationItemCreate(
        ConversationItemCreateEvent.builder()
            .item(
                RealtimeConversationItemUserMessage.builder()
                    .object_(JsonMissing.of())
                    .addContent(
                        RealtimeConversationItemUserMessage.Content.builder()
                            .type(RealtimeConversationItemUserMessage.Content.Type.INPUT_TEXT)
                            .text("What Prince album sold the most copies?")
                            .build())
                    .build())
            .build()));

1
2
3
4
5
6
7using OpenAI.Realtime;

#pragma warning disable OPENAI002

RealtimeMessageItem item = RealtimeItem.CreateUserMessageItem("What Prince album sold the most copies?");
item.Id = Guid.NewGuid().ToString("N");
await session.SendCommandAsync(new RealtimeClientCommandConversationItemCreate(item), timeout.Token);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18connection.conversation.items.create(
  type: :message,
  role: :user,
  content: [
    {
      type: :input_text,
      text: "What is the weather like today?"
    }
  ]
)

receipt = connection.find do |event|
  raise event.error.message if event.is_a?(OpenAI::Realtime::RealtimeErrorEvent)
  next unless event.is_a?(OpenAI::Realtime::ConversationItemDone)

  event.item.is_a?(OpenAI::Realtime::RealtimeConversationItemUserMessage)
end
raise "Connection closed before the conversation item was acknowledged" unless receipt

Depois de adicionar a mensagem do usuário à conversa, envie o evento response.create para que o modelo comece a responder. Escolha uma única modalidade de saída. A modalidade audio gera áudio com a respectiva transcrição, e text gera apenas texto. Para gerar apenas texto, especifique essa opção ao enviar o evento response.create do cliente, como no exemplo abaixo.

Gere uma resposta somente em texto

JavaScript

1
2
3
4
5
6
7
8
9const event = {
  type: "response.create",
  response: {
    output_modalities: ["text"],
  },
};

// WebRTC data channel and WebSocket both have .send()
ws.send(JSON.stringify(event));

1
2event = {"type": "response.create", "response": {"output_modalities": ["text"]}}
ws.send(json.dumps(event))

1
2
3
4
5
6
7
8
9if err := conn.Send(ctx, realtime.RealtimeClientEventUnionParam{
	OfResponseCreate: &realtime.ResponseCreateEventParam{
		Response: realtime.RealtimeResponseCreateParams{
			OutputModalities: []string{"text"},
		},
	},
}); err != nil {
	return err
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14import com.openai.client.okhttp.OkHttpClient;
import com.openai.core.ClientOptions;
import com.openai.helpers.RealtimeConnection;
import com.openai.helpers.RealtimeWebSocketOptions;
import com.openai.models.realtime.*;

connection.send(
    RealtimeClientEvent.ofResponseCreate(
        ResponseCreateEvent.builder()
            .response(
                RealtimeResponseCreateParams.builder()
                    .addOutputModality(RealtimeResponseCreateParams.OutputModality.TEXT)
                    .build())
            .build()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14using OpenAI.Realtime;

#pragma warning disable OPENAI002

await session.SendCommandAsync(new RealtimeClientCommandResponseCreate
{
    ResponseOptions = new()
    {
        OutputModalities =
        {
            RealtimeOutputModality.Text
        }
    }
}, timeout.Token);

1
2
3
4
5
6
7
8
9
10
11
12
13
14connection.response.create(
  output_modalities: [:text],
  instructions: "Respond with a concise text message."
)

response_done = connection.find do |event|
  raise event.error.message if event.is_a?(OpenAI::Realtime::RealtimeErrorEvent)
  next unless event.is_a?(OpenAI::Realtime::ResponseDoneEvent)

  raise "Response failed: #{event.response.status}" unless event.response.status == :completed

  true
end
raise "Connection closed before the response completed" unless response_done

Quando a resposta estiver concluída, o servidor emitirá o evento response.done. Esse evento contém o texto completo gerado pelo modelo, como mostra o exemplo abaixo.

Escute o evento response.done para ver o resultado final

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13function handleEvent(message) {
  const data = "data" in message ? message.data : message.toString();
  const serverEvent = JSON.parse(data);
  if (serverEvent.type === "response.done") {
    console.log(serverEvent.response.output[0]);
  }
}

// Listen for server messages (WebRTC)
// dataChannel.addEventListener("message", handleEvent);

// Listen for server messages (WebSocket)
ws.on("message", handleEvent);

1
2
3
4def on_message(ws, message):
    server_event = json.loads(message)
    if server_event["type"] == "response.done":
        print(server_event["response"]["output"][0])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31func receiveUntil(ctx context.Context, conn *realtime.RealtimeConnection, terminal string) (realtime.RealtimeServerEventUnion, error) {
	for {
		event, err := conn.Recv(ctx)
		if err != nil {
			return event, fmt.Errorf("waiting for %s: %w", terminal, err)
		}
		if event.Type == "error" {
			return event, fmt.Errorf("Realtime API error: %s", event.OfRealtimeErrorEvent.Error.Message)
		}
		if event.Type == "response.done" && event.OfResponseDoneEvent.Response.Status != "completed" {
			return event, fmt.Errorf("response ended with status %s", event.OfResponseDoneEvent.Response.Status)
		}
		if event.Type == "response.done" {
			response := event.OfResponseDoneEvent.Response
			fmt.Println("Response status:", response.Status)
			for _, output := range response.Output {
				item := output.OfRealtimeConversationItemAssistantMessage
				if item.Type == "message" {
					for _, content := range item.Content {
						if content.Type == "output_text" {
							fmt.Print(content.Text)
						}
					}
				}
			}
		}
		if event.Type == terminal {
			return event, nil
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23import com.openai.client.okhttp.OkHttpClient;
import com.openai.core.ClientOptions;
import com.openai.helpers.RealtimeConnection;
import com.openai.helpers.RealtimeWebSocketOptions;
import com.openai.models.realtime.*;

static void handleEvent(RealtimeServerEvent event) {
  event
      .responseDone()
      .ifPresent(
          done -> {
            if (!done.response()
                .status()
                .filter(RealtimeResponse.Status.COMPLETED::equals)
                .isPresent())
              throw new IllegalStateException(
                  "Response ended with status "
                      + done.response().status()
                      + ": "
                      + done.response().statusDetails());
            System.out.println(done.response().output());
          });
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14using OpenAI.Realtime;

#pragma warning disable OPENAI002

internal static void HandleEvent(RealtimeServerUpdate update)
{
    if (update is RealtimeServerUpdateResponseDone completion && completion.Response.Status != RealtimeResponseStatus.Completed)
        throw new InvalidOperationException($"Response ended with status {completion.Response.Status}: {System.ClientModel.Primitives.ModelReaderWriter.Write(completion.Response)}");
    if (update is RealtimeServerUpdateResponseDone done)
    {
        foreach (RealtimeItem item in done.Response.OutputItems)
            Console.WriteLine(System.ClientModel.Primitives.ModelReaderWriter.Write(item));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14response_done = connection.find do |event|
  next unless event.is_a?(OpenAI::Realtime::ResponseDoneEvent)

  puts("Response status: #{event.response.status}")
  Array(event.response.output).each do |item|
    next unless item.is_a?(OpenAI::Realtime::RealtimeConversationItemAssistantMessage)

    item.content.each do |content|
      puts(content.text) if content.type == :output_text
    end
  end
  true
end
raise "Connection closed before the response completed" unless response_done

Enquanto o modelo gera a resposta, o servidor emite vários eventos de ciclo de vida. Você pode escutar eventos como response.output_text.delta para mostrar o progresso ao usuário em tempo real. A coluna Eventos relacionados do servidor lista os eventos que o servidor emite, na ordem aproximada de emissão. A tabela também inclui os eventos do cliente relevantes para a geração de texto.

Eventos relacionados do cliente Eventos relacionados do servidor

Eventos relacionados do cliente	Eventos relacionados do servidor
`conversation.item.create` `response.create`	`conversation.item.added` `conversation.item.done` `response.created` `response.output_item.added` `response.content_part.added` `response.output_text.delta` `response.output_text.done` `response.content_part.done` `response.output_item.done` `response.done` `rate_limits.updated`

conversation.item.create

response.create

conversation.item.added

conversation.item.done

response.created

response.output_item.added

response.content_part.added

response.output_text.delta

response.output_text.done

response.content_part.done

response.output_item.done

response.done

rate_limits.updated

Entradas e saídas de áudio

Um dos principais recursos da Realtime API é a interação direta por voz com o modelo, sem uma etapa intermediária de conversão de texto em fala ou de fala em texto. Isso reduz a latência das interfaces de voz e dá ao modelo mais informações sobre o tom e a entonação da fala do usuário.

Opções de voz

Você pode configurar uma sessão Realtime para usar uma das vozes integradas ao gerar áudio. Defina voice ao criar a sessão (ou em um evento response.create) para escolher a voz do modelo. As opções atuais são alloy, ash, ballad, coral, echo, sage, shimmer, verse, marin e cedar. Depois que o modelo emitir áudio, você não poderá mais alterar voice nessa sessão. Para obter a melhor qualidade, recomendamos marin ou cedar.

Como trabalhar com áudio via WebRTC

Quando você se conecta à Realtime API via WebRTC, a Realtime API participa de uma conexão ponto a ponto com o cliente. O cliente recebe o áudio gerado pelo modelo como um fluxo de mídia remoto. Dispositivos de áudio capturam a entrada para o modelo (getUserMedia), e os fluxos de mídia são adicionados à conexão ponto a ponto como faixas.

O exemplo do guia de conexão via WebRTC mostra uma configuração básica do áudio local e remoto com as APIs do navegador.

1
2
3
4
5
6
7
8
9
10
11
12
13// Create a peer connection
const pc = new RTCPeerConnection();

// Set up to play remote audio from the model
const audioEl = document.createElement("audio");
audioEl.autoplay = true;
pc.ontrack = (e) => (audioEl.srcObject = e.streams[0]);

// Add local audio track for microphone input in the browser
const ms = await navigator.mediaDevices.getUserMedia({
  audio: true,
});
pc.addTrack(ms.getTracks()[0]);

O trecho acima permite interagir com a Realtime API. Para explorar outras possibilidades de interface, consulte o repositório de exemplos de WebRTC. Você também pode experimentar as demonstrações desses exemplos.

Com a captura e a transmissão de mídia no navegador, você pode, por exemplo, ligar e desligar microfones e selecionar o dispositivo de entrada.

Eventos do cliente e do servidor para áudio via WebRTC

Por padrão, os clientes WebRTC podem enviar áudio de entrada à Realtime API sem precisar enviar antes nenhum evento do cliente. Assim que você adiciona uma faixa de áudio local à conexão ponto a ponto, o usuário já pode começar a falar.

Os clientes WebRTC continuam recebendo eventos de ciclo de vida do servidor enquanto o áudio trafega nos dois sentidos pela conexão ponto a ponto. Veja alguns exemplos.

Quando a faixa de mídia local transmite a entrada, você recebe eventos input_audio_buffer.speech_started do servidor.
Quando a entrada de áudio local termina, você recebe o evento input_audio_buffer.speech_stopped.
Você recebe eventos com atualizações incrementais da transcrição de áudio em andamento.
Você recebe um evento response.done quando o modelo conclui a transcrição e o envio da resposta.

As APIs do WebRTC para fluxos de mídia podem oferecer todo o controle de que você precisa. Em alguns casos, porém, pode ser necessário usar interfaces de nível mais baixo para a entrada e a saída de áudio. A seção sobre WebSockets a seguir traz mais informações e lista os eventos necessários para controlar a entrada de áudio em detalhes.

Como trabalhar com áudio via WebSockets

Com um WebSocket, enviar mídia pelo cliente e receber mídia do servidor exige algumas etapas adicionais. A tabela abaixo descreve o fluxo de eventos necessário para enviar e receber áudio durante uma sessão via WebSocket.

Os eventos aparecem na ordem do ciclo de vida, embora alguns deles, como os eventos delta, possam ocorrer simultaneamente.

Etapa do ciclo de vida Eventos do cliente Eventos do servidor

Inicialização da sessão

Etapa do ciclo de vida	Eventos do cliente	Eventos do servidor
Inicialização da sessão	`session.update`	`session.created` `session.updated`
Entrada de áudio do usuário	`conversation.item.create` (envia a mensagem de áudio inteira) `input_audio_buffer.append` (transmite o áudio em blocos) `input_audio_buffer.commit` (usado quando a VAD está desativada) `response.create` (usado quando a VAD está desativada)	`input_audio_buffer.speech_started` `input_audio_buffer.speech_stopped` `input_audio_buffer.committed`
Saída de áudio do servidor	`input_audio_buffer.clear` (usado quando a VAD está desativada)	`conversation.item.added` `conversation.item.done` `response.created` `response.output_item.added` `response.content_part.added` `response.output_audio.delta` `response.output_audio.done` `response.output_audio_transcript.delta` `response.output_audio_transcript.done` `response.output_text.delta` `response.output_text.done` `response.content_part.done` `response.output_item.done` `response.done` `rate_limits.updated`

session.update

session.created

session.updated

Entrada de áudio do usuário

conversation.item.create

(envia a mensagem de áudio inteira)

input_audio_buffer.append

(transmite o áudio em blocos)

input_audio_buffer.commit

(usado quando a VAD está desativada)

response.create

(usado quando a VAD está desativada)

input_audio_buffer.speech_started

input_audio_buffer.speech_stopped

input_audio_buffer.committed

Saída de áudio do servidor

input_audio_buffer.clear

(usado quando a VAD está desativada)

conversation.item.added

conversation.item.done

response.created

response.output_item.added

response.content_part.added

response.output_audio.delta

response.output_audio.done

response.output_audio_transcript.delta

response.output_audio_transcript.done

response.output_text.delta

response.output_text.done

response.content_part.done

response.output_item.done

response.done

rate_limits.updated

Transmita áudio de entrada ao servidor

Para transmitir áudio de entrada ao servidor, use o evento input_audio_buffer.append do cliente. Esse evento exige que você envie blocos de bytes de áudio codificados em Base64 à Realtime API pelo socket. Cada bloco pode ter no máximo 15 MB.

Defina session.audio.input.format em session.update. Para PCM, use {"type": "audio/pcm", "rate": 24000} e envie áudio mono a 24 kHz.

Acrescente bytes de áudio de entrada à conversa

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77import fs from "fs";
import decodeAudio from "audio-decode";

// Converts Float32Array of audio data to PCM16 ArrayBuffer
function floatTo16BitPCM(float32Array) {
  const buffer = new ArrayBuffer(float32Array.length * 2);
  const view = new DataView(buffer);
  let offset = 0;
  for (let i = 0; i < float32Array.length; i++, offset += 2) {
    const sample = Math.max(-1, Math.min(1, float32Array[i]));
    view.setInt16(
      offset,
      Math.round(sample * (sample < 0 ? 0x8000 : 0x7fff)),
      true
    );
  }
  return buffer;
}

// Converts a Float32Array to base64-encoded PCM16 data
function base64EncodeAudio(float32Array) {
  const arrayBuffer = floatTo16BitPCM(float32Array);
  let binary = "";
  let bytes = new Uint8Array(arrayBuffer);
  const chunkSize = 0x8000; // 32KB chunk size
  for (let i = 0; i < bytes.length; i += chunkSize) {
    let chunk = bytes.subarray(i, i + chunkSize);
    binary += String.fromCharCode(...chunk);
  }
  return btoa(binary);
}

// Fills the audio buffer with the contents of three files,
// then asks the model to generate a response.
const files = [
  "fixtures/sample1.wav",
  "fixtures/sample2.wav",
  "fixtures/sample3.wav",
];

// Manual commit and response creation require automatic turn detection off.
ws.send(
  JSON.stringify({
    type: "session.update",
    session: {
      type: "realtime",
      audio: { input: { turn_detection: null } },
    },
  })
);

for (const filename of files) {
  const audioFile = fs.readFileSync(filename);
  const audioBuffer = await decodeAudio(audioFile);
  if (
    audioBuffer.sampleRate !== 24000 ||
    audioBuffer.channelData.length !== 1
  ) {
    throw new Error("Expected 24 kHz mono audio: " + filename);
  }
  const channelData = audioBuffer.channelData[0];
  const base64Chunk = base64EncodeAudio(channelData);
  ws.send(
    JSON.stringify({
      type: "input_audio_buffer.append",
      audio: base64Chunk,
    })
  );
}

ws.send(JSON.stringify({ type: "input_audio_buffer.commit" }));
ws.send(
  JSON.stringify({
    type: "response.create",
    response: { output_modalities: ["audio"] },
  })
);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32import base64
import json
import struct
import soundfile as sf
from websocket import create_connection

# ... create websocket-client named ws ...


def float_to_16bit_pcm(float32_array):
    clipped = [max(-1.0, min(1.0, x)) for x in float32_array]
    pcm16 = b"".join(struct.pack("<h", min(32767, int(x * 32768))) for x in clipped)
    return pcm16


def base64_encode_audio(float32_array):
    pcm_bytes = float_to_16bit_pcm(float32_array)
    encoded = base64.b64encode(pcm_bytes).decode("ascii")
    return encoded


files = ["./path/to/sample1.wav", "./path/to/sample2.wav", "./path/to/sample3.wav"]

for filename in files:
    data, samplerate = sf.read(filename, dtype="float32")
    if samplerate != 24000 or data.ndim != 1:
        raise ValueError(f"Expected 24 kHz mono audio: {filename}")
    base64_chunk = base64_encode_audio(data)

    # Send the client event
    event = {"type": "input_audio_buffer.append", "audio": base64_chunk}
    ws.send(json.dumps(event))

1
2
3
4
5
6
7// audio contains mono PCM16 samples at 24 kHz.
for start := 0; start < len(audio); start += 9600 {
	end := min(start+9600, len(audio))
	if err := conn.Send(ctx, realtime.RealtimeClientEventParamOfInputAudioBufferAppend(base64.StdEncoding.EncodeToString(audio[start:end]))); err != nil {
		return err
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30import com.openai.client.okhttp.OkHttpClient;
import com.openai.core.ClientOptions;
import com.openai.helpers.RealtimeConnection;
import com.openai.helpers.RealtimeWebSocketOptions;
import com.openai.models.realtime.*;
import java.util.Base64;

// Call for each PCM16, 24 kHz, mono chunk supplied by your audio source.
static void appendAudio(RealtimeConnection connection, byte[] pcmAudio) throws Exception {
  String base64Audio = Base64.getEncoder().encodeToString(pcmAudio);
  send(
      connection,
      RealtimeClientEvent.ofInputAudioBufferAppend(
          InputAudioBufferAppendEvent.builder().audio(base64Audio).build()));
}

// Retry only explicit admission rejections; these guarantee nothing was sent.
private static void send(RealtimeConnection connection, RealtimeClientEvent event)
    throws Exception {
  long deadline = System.nanoTime() + java.util.concurrent.TimeUnit.SECONDS.toNanos(5);
  while (true) {
    try {
      connection.send(event);
      return;
    } catch (com.openai.core.http.WebSocketWriteNotAttempted.Busy busy) {
      if (System.nanoTime() >= deadline) throw busy;
      Thread.sleep(10);
    }
  }
}

1
2
3
4
5
6
7
8
9using OpenAI.Realtime;

#pragma warning disable OPENAI002

// Call for each PCM16, 24 kHz, mono chunk supplied by your audio source.
internal static async Task AppendAudioAsync(RealtimeSessionClient session, BinaryData pcmAudio, CancellationToken cancellationToken)
{
    await session.SendCommandAsync(new RealtimeClientCommandInputAudioBufferAppend(pcmAudio), cancellationToken);
}

1
2
3
4
5File.open("speech.pcm", "rb") do |audio|
  while (chunk = audio.read(9_600))
    connection.input_audio_buffer.append_bytes(chunk)
  end
end

Envie mensagens de áudio completas

Você também pode criar mensagens na conversa a partir de gravações de áudio completas. Use o evento conversation.item.create do cliente para criar mensagens com conteúdo do tipo input_audio.

Crie itens na conversa com gravações de áudio completas

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18const fullAudio = "<a base64-encoded string of audio bytes>";

const event = {
  type: "conversation.item.create",
  item: {
    type: "message",
    role: "user",
    content: [
      {
        type: "input_audio",
        audio: fullAudio,
      },
    ],
  },
};

// WebRTC data channel and WebSocket both have .send()
dataChannel.send(JSON.stringify(event));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17fullAudio = "<a base64-encoded string of audio bytes>"

event = {
    "type": "conversation.item.create",
    "item": {
        "type": "message",
        "role": "user",
        "content": [
            {
                "type": "input_audio",
                "audio": fullAudio,
            }
        ],
    },
}

ws.send(json.dumps(event))

1
2
3
4
5
6
7
8
9
10if err := conn.Send(ctx, realtime.RealtimeClientEventParamOfConversationItemCreate(realtime.RealtimeConversationItemUserMessageParam{
	Content: []realtime.RealtimeConversationItemUserMessageContentParam{
		{
			Audio: openai.String(base64.StdEncoding.EncodeToString(audio)),
			Type:  "input_audio",
		},
	},
})); err != nil {
	return err
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36import com.openai.client.okhttp.OkHttpClient;
import com.openai.core.ClientOptions;
import com.openai.core.JsonMissing;
import com.openai.helpers.RealtimeConnection;
import com.openai.helpers.RealtimeWebSocketOptions;
import com.openai.models.realtime.*;
import java.util.Base64;

// Pass the complete PCM16, 24 kHz, mono recording from your application.
static void sendAudioItem(RealtimeConnection connection, byte[] pcmAudio) throws Exception {
  String fullAudio = Base64.getEncoder().encodeToString(pcmAudio);
  var event =
      RealtimeClientEvent.ofConversationItemCreate(
          ConversationItemCreateEvent.builder()
              .item(
                  RealtimeConversationItemUserMessage.builder()
                      .object_(JsonMissing.of())
                      .addContent(
                          RealtimeConversationItemUserMessage.Content.builder()
                              .type(RealtimeConversationItemUserMessage.Content.Type.INPUT_AUDIO)
                              .audio(fullAudio)
                              .build())
                      .build())
              .build());
  // Retry only explicit admission rejections; these guarantee nothing was sent.
  long deadline = System.nanoTime() + java.util.concurrent.TimeUnit.SECONDS.toNanos(5);
  while (true) {
    try {
      connection.send(event);
      return;
    } catch (com.openai.core.http.WebSocketWriteNotAttempted.Busy busy) {
      if (System.nanoTime() >= deadline) throw busy;
      Thread.sleep(10);
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13using OpenAI.Realtime;

#pragma warning disable OPENAI002

// Pass the complete PCM16, 24 kHz, mono recording from your application.
internal static async Task<string> SendAudioItemAsync(RealtimeSessionClient session, BinaryData pcmAudio, CancellationToken cancellationToken)
{
    RealtimeMessageItem item = RealtimeItem.CreateUserMessageItem([new RealtimeInputAudioMessageContentPart(pcmAudio)]);
    string itemId = Guid.NewGuid().ToString("N");
    item.Id = itemId;
    await session.SendCommandAsync(new RealtimeClientCommandConversationItemCreate(item), cancellationToken);
    return itemId;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20audio = Base64.strict_encode64(File.binread("speech.pcm"))

connection.conversation.items.create(
  type: :message,
  role: :user,
  content: [
    {
      type: :input_audio,
      audio: audio
    }
  ]
)

receipt = connection.find do |event|
  raise event.error.message if event.is_a?(OpenAI::Realtime::RealtimeErrorEvent)

  event.is_a?(OpenAI::Realtime::ConversationItemDone) &&
    event.item.is_a?(OpenAI::Realtime::RealtimeConversationItemUserMessage)
end
raise "Connection closed before the audio item was acknowledged" unless receipt

Como trabalhar com a saída de áudio de um WebSocket

Para reproduzir o áudio de saída no cliente, por exemplo, em um navegador, recomendamos usar WebRTC em vez de WebSockets. O WebRTC transmite mídia aos dispositivos clientes com mais confiabilidade quando as condições da rede variam.

Para trabalhar com saída de áudio em aplicativos que usam um WebSocket na comunicação entre servidores, escute os eventos response.output_audio.delta. Eles contêm blocos de dados de áudio do modelo codificados em Base64. Você pode armazenar esses blocos em um buffer e gravá-los em um arquivo ou transmiti-los imediatamente para outro destino, como uma chamada telefônica via Twilio.

Os eventos response.output_audio.done e response.done contêm apenas a transcrição do áudio. Para obter os bytes de áudio, escute os eventos response.output_audio.delta.

Você pode configurar o formato dos blocos de saída para a sessão inteira ou para cada resposta.

Para a sessão, defina session.audio.output.format em session.update.
Para a resposta, defina response.audio.output.format em response.create.

Escute os eventos response.output_audio.delta

JavaScript

1
2
3
4
5
6
7
8
9
10function handleEvent(message) {
  const serverEvent = JSON.parse(message.toString());
  if (serverEvent.type === "response.output_audio.delta") {
    const audio = Buffer.from(serverEvent.delta, "base64");
    console.log(`Received ${audio.length} audio bytes`);
  }
}

// Listen for server messages (WebSocket)
ws.on("message", handleEvent);

1
2
3
4
5def on_message(ws, message):
    server_event = json.loads(message)
    if server_event["type"] == "response.output_audio.delta":
        # Access Base64-encoded audio chunks:
        print(server_event["delta"])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24func receiveUntil(ctx context.Context, conn *realtime.RealtimeConnection, terminal string) (realtime.RealtimeServerEventUnion, error) {
	for {
		event, err := conn.Recv(ctx)
		if err != nil {
			return event, fmt.Errorf("waiting for %s: %w", terminal, err)
		}
		if event.Type == "response.output_audio.delta" {
			audio, err := base64.StdEncoding.DecodeString(event.OfResponseAudioDeltaEvent.Delta)
			if err != nil {
				return event, err
			}
			fmt.Printf("Received %d audio bytes\n", len(audio))
		}
		if event.Type == "error" {
			return event, fmt.Errorf("Realtime API error: %s", event.OfRealtimeErrorEvent.Error.Message)
		}
		if event.Type == "response.done" && event.OfResponseDoneEvent.Response.Status != "completed" {
			return event, fmt.Errorf("response ended with status %s", event.OfResponseDoneEvent.Response.Status)
		}
		if event.Type == terminal {
			return event, nil
		}
	}
}

1
2
3
4
5
6
7
8
9import com.openai.client.okhttp.OkHttpClient;
import com.openai.core.ClientOptions;
import com.openai.helpers.RealtimeConnection;
import com.openai.helpers.RealtimeWebSocketOptions;
import com.openai.models.realtime.*;

static void handleEvent(RealtimeServerEvent event) {
  event.responseOutputAudioDelta().ifPresent(delta -> System.out.println(delta.delta()));
}

1
2
3
4
5
6
7
8
9using OpenAI.Realtime;

#pragma warning disable OPENAI002

internal static void HandleEvent(RealtimeServerUpdate update)
{
    if (update is RealtimeServerUpdateResponseOutputAudioDelta delta)
        Console.WriteLine(Convert.ToBase64String(delta.Delta.ToArray()));
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14response_done = connection.find do |event|
  case event
  when OpenAI::Realtime::ResponseAudioDeltaEvent
    audio_bytes = Base64.strict_decode64(event.delta)
    puts("Received #{audio_bytes.bytesize} audio bytes")
  when OpenAI::Realtime::RealtimeErrorEvent
    raise event.error.message
  when OpenAI::Realtime::ResponseDoneEvent
    raise "Response failed: #{event.response.status}" unless event.response.status == :completed

    true
  end
end
raise "Connection closed before the response completed" unless response_done

Entradas de imagem

gpt-realtime-2 e gpt-realtime também aceitam imagens como entrada. Você pode anexar uma imagem como parte do conteúdo de uma mensagem do usuário, e o modelo pode levar o conteúdo da imagem em conta ao responder.

Adicione uma imagem à conversa

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18const base64Image = "<a base64-encoded string of image bytes>";

const event = {
  type: "conversation.item.create",
  item: {
    type: "message",
    role: "user",
    content: [
      {
        type: "input_image",
        image_url: `data:image/{format};base64,${base64Image}`,
      },
    ],
  },
};

// WebRTC data channel and WebSocket both have .send()
dataChannel.send(JSON.stringify(event));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24if err := conn.Send(ctx, realtime.RealtimeClientEventParamOfConversationItemCreate(realtime.RealtimeConversationItemUserMessageParam{
	Content: []realtime.RealtimeConversationItemUserMessageContentParam{
		{
			ImageURL: openai.String("data:image/png;base64," + base64.StdEncoding.EncodeToString(image)),
			Type:     "input_image",
		},
		{
			Text: openai.String("Describe this image."),
			Type: "input_text",
		},
	},
})); err != nil {
	return err
}

if err := conn.Send(ctx, realtime.RealtimeClientEventUnionParam{
	OfResponseCreate: &realtime.ResponseCreateEventParam{
		Response: realtime.RealtimeResponseCreateParams{
			OutputModalities: []string{"text"},
		},
	},
}); err != nil {
	return err
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26encoded_image = Base64.strict_encode64(File.binread("image.png"))

connection.conversation.items.create(
  type: :message,
  role: :user,
  content: [
    {
      type: :input_image,
      image_url: "data:image/png;base64,#{encoded_image}"
    },
    {
      type: :input_text,
      text: "Describe this image."
    }
  ]
)
connection.response.create(output_modalities: [:text])

completion = connection.find do |event|
  raise event.error.message if event.is_a?(OpenAI::Realtime::RealtimeErrorEvent)

  event.is_a?(OpenAI::Realtime::ResponseDoneEvent)
end
unless completion.is_a?(OpenAI::Realtime::ResponseDoneEvent) && completion.response.status == :completed
  raise "The Realtime response did not complete"
end

Detecção de atividade de voz

Por padrão, as sessões Realtime usam detecção de atividade de voz (VAD). Com esse recurso, a API identifica quando o usuário começa e para de falar e responde automaticamente.

Saiba como configurar a VAD no guia de detecção de atividade de voz.

Desative a VAD

Para desativar a VAD, defina turn_detection como null no evento session.update do cliente. Isso é útil em interfaces que exigem controle detalhado da entrada de áudio, como aquelas em que o usuário pressiona um botão para falar.

Com a VAD desativada, o cliente precisa emitir manualmente alguns eventos adicionais para acionar respostas em áudio.

Envie manualmente input_audio_buffer.commit para criar um item na conversa com a entrada do usuário.
Envie manualmente response.create para acionar uma resposta em áudio do modelo.
Envie input_audio_buffer.clear antes de iniciar uma nova entrada do usuário.

Mantenha a VAD ativada e desative as respostas automáticas

Para manter a VAD ativada e decidir manualmente quando gerar uma resposta, defina turn_detection.interrupt_response e turn_detection.create_response como false no evento session.update do cliente. A VAD continua funcionando, mas a API deixa de criar respostas automaticamente. Os clientes podem acioná-las manualmente com um evento response.create.

Essa configuração pode ser útil para moderação, validação de entradas ou implementações de RAG quando vale a pena aceitar um pouco mais de latência na interação para ter controle sobre as entradas.

Crie respostas fora da conversa padrão

Por padrão, todas as respostas geradas durante uma sessão passam a fazer parte do estado da conversa da sessão (a “conversa padrão”). Em alguns casos, você pode querer que o modelo gere respostas fora do contexto da conversa padrão ou que gere várias respostas simultaneamente. Você também pode escolher com mais precisão quais itens da conversa o modelo considera ao gerar uma resposta (por exemplo, apenas os últimos N turnos).

Para gerar respostas “fora de banda”, que não são adicionadas ao estado da conversa padrão, defina o campo response.conversation como a string none ao criar a resposta com o evento response.create do cliente.

Ao criar uma resposta fora de banda, você provavelmente também vai querer identificar quais eventos do servidor correspondem a ela. Inclua metadata na resposta do modelo para identificar qual resposta está sendo gerada para o evento enviado pelo cliente.

Crie uma resposta do modelo fora de banda

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23const prompt = `
Analyze the conversation so far. If it is related to support, output
"support". If it is related to sales, output "sales".
`;

  const event = {
    type: "response.create",
    response: {
      // Setting to "none" indicates the response is out of band
      // and will not be added to the default conversation
      conversation: "none",

      // Set metadata to help identify responses sent back from the model
      metadata: { topic: "classification" },

      // Set any other available response fields
      output_modalities: ["text"],
      instructions: prompt,
    },
  };

  // WebRTC data channel and WebSocket both have .send()
  ws.send(JSON.stringify(event));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20prompt = """
Analyze the conversation so far. If it is related to support, output
"support". If it is related to sales, output "sales".
"""

event = {
    "type": "response.create",
    "response": {
        # Setting to "none" indicates the response is out of band,
        # and will not be added to the default conversation
        "conversation": "none",
        # Set metadata to help identify responses sent back from the model
        "metadata": {"topic": "classification"},
        # Set any other available response fields
        "output_modalities": ["text"],
        "instructions": prompt,
    },
}

ws.send(json.dumps(event))

1
2
3
4
5
6
7
8
9
10
11
12
13
14if err := conn.Send(ctx, realtime.RealtimeClientEventUnionParam{
	OfResponseCreate: &realtime.ResponseCreateEventParam{
		Response: realtime.RealtimeResponseCreateParams{
			Instructions: openai.String("\nAnalyze the conversation so far. If it is related to support, output\n\"support\". If it is related to sales, output \"sales\".\n"),
			Metadata: shared.Metadata{
				"topic": "classification",
			},
			Conversation:     "none",
			OutputModalities: []string{"text"},
		},
	},
}); err != nil {
	return err
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import com.openai.client.okhttp.OkHttpClient;
import com.openai.core.ClientOptions;
import com.openai.core.JsonValue;
import com.openai.helpers.RealtimeConnection;
import com.openai.helpers.RealtimeWebSocketOptions;
import com.openai.models.realtime.*;

connection.send(
    RealtimeClientEvent.ofResponseCreate(
        ResponseCreateEvent.builder()
            .response(
                RealtimeResponseCreateParams.builder()
                    .conversation("none")
                    .metadata(
                        RealtimeResponseCreateParams.Metadata.builder()
                            .putAdditionalProperty("topic", JsonValue.from("classification"))
                            .build())
                    .addOutputModality(RealtimeResponseCreateParams.OutputModality.TEXT)
                    .instructions(
                        "Analyze the conversation so far. If it is related to support, output \"support\". If it is related to sales, output \"sales\".")
                    .build())
            .build()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20using OpenAI.Realtime;

#pragma warning disable OPENAI002

await session.SendCommandAsync(new RealtimeClientCommandResponseCreate
{
    ResponseOptions = new()
    {
        DefaultConversationConfiguration = RealtimeResponseDefaultConversationConfiguration.None,
        Metadata = new Dictionary<string, BinaryData>
        {
            ["topic"] = BinaryData.FromObjectAsJson("classification")
        },
        OutputModalities =
        {
            RealtimeOutputModality.Text
        },
        Instructions = "Analyze the conversation so far. If it is related to support, output \"support\". If it is related to sales, output \"sales\"."
    }
}, timeout.Token);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16connection.response.create(
  conversation: :none,
  metadata: { topic: "classification" },
  output_modalities: [:text],
  instructions: "Classify the conversation as support or sales."
)

response_done = connection.find do |event|
  raise event.error.message if event.is_a?(OpenAI::Realtime::RealtimeErrorEvent)
  next unless event.is_a?(OpenAI::Realtime::ResponseDoneEvent)

  raise "Response failed: #{event.response.status}" unless event.response.status == :completed

  true
end
raise "Connection closed before the response completed" unless response_done

Agora, ao escutar o evento response.done do servidor, você pode identificar o resultado da resposta fora de banda.

Crie uma resposta do modelo fora de banda

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22function handleEvent(message) {
  const data = "data" in message ? message.data : message.toString();
  const serverEvent = JSON.parse(data);
  if (
    serverEvent.type === "response.done" &&
    serverEvent.response.metadata?.topic === "classification"
  ) {
    const { response } = serverEvent;
    if (response.status !== "completed" || response.output.length === 0) {
      throw new Error(
        "Classification response ended with status " + response.status
      );
    }
    console.log(response.output[0]);
  }
}

// Listen for server messages (WebRTC)
// dataChannel.addEventListener("message", handleEvent);

// Listen for server messages (WebSocket)
ws.on("message", handleEvent);

1
2
3
4
5
6
7
8
9
10
11
12def on_message(ws, message):
    server_event = json.loads(message)
    if server_event["type"] != "response.done":
        return
    response = server_event["response"]
    if (response.get("metadata") or {}).get("topic") != "classification":
        return
    if response["status"] != "completed" or not response["output"]:
        raise RuntimeError(
            f"Classification response ended with status {response['status']}"
        )
    print(response["output"][0])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34func receiveUntil(ctx context.Context, conn *realtime.RealtimeConnection, terminal string) (realtime.RealtimeServerEventUnion, error) {
	for {
		event, err := conn.Recv(ctx)
		if err != nil {
			return event, fmt.Errorf("waiting for %s: %w", terminal, err)
		}
		if event.Type == "error" {
			return event, fmt.Errorf("Realtime API error: %s", event.OfRealtimeErrorEvent.Error.Message)
		}
		if event.Type == "response.done" && event.OfResponseDoneEvent.Response.Metadata["topic"] != "classification" {
			continue
		}
		if event.Type == "response.done" && event.OfResponseDoneEvent.Response.Status != "completed" {
			return event, fmt.Errorf("response ended with status %s", event.OfResponseDoneEvent.Response.Status)
		}
		if event.Type == "response.done" {
			response := event.OfResponseDoneEvent.Response
			fmt.Println("Response status:", response.Status)
			for _, output := range response.Output {
				item := output.OfRealtimeConversationItemAssistantMessage
				if item.Type == "message" {
					for _, content := range item.Content {
						if content.Type == "output_text" {
							fmt.Print(content.Text)
						}
					}
				}
			}
		}
		if event.Type == terminal {
			return event, nil
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import com.openai.client.okhttp.OkHttpClient;
import com.openai.core.ClientOptions;
import com.openai.core.JsonValue;
import com.openai.helpers.RealtimeConnection;
import com.openai.helpers.RealtimeWebSocketOptions;
import com.openai.models.realtime.*;

static boolean handleEvent(RealtimeServerEvent event) {
  if (event.responseDone().isEmpty()) return false;
  var response = event.responseDone().orElseThrow().response();
  if (!response
      .metadata()
      .map(m -> m._additionalProperties().get("topic"))
      .flatMap(JsonValue::asString)
      .filter("classification"::equals)
      .isPresent()) return false;
  if (!response.status().filter(RealtimeResponse.Status.COMPLETED::equals).isPresent())
    throw new IllegalStateException(
        "Response ended with status " + response.status() + ": " + response.statusDetails());
  System.out.println(response.output());
  return true;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16using OpenAI.Realtime;

#pragma warning disable OPENAI002

internal static bool HandleEvent(RealtimeServerUpdate update)
{
    if (update is not RealtimeServerUpdateResponseDone done ||
        !done.Response.Metadata.TryGetValue("topic", out BinaryData? topic) ||
        topic.ToObjectFromJson<string>() != "classification")
        return false;
    if (done.Response.Status != RealtimeResponseStatus.Completed)
        throw new InvalidOperationException($"Response ended with status {done.Response.Status}: {System.ClientModel.Primitives.ModelReaderWriter.Write(done.Response)}");
    foreach (RealtimeItem item in done.Response.OutputItems)
        Console.WriteLine(System.ClientModel.Primitives.ModelReaderWriter.Write(item));
    return true;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15response_done = connection.find do |event|
  next unless event.is_a?(OpenAI::Realtime::ResponseDoneEvent)
  next unless event.response.metadata&.fetch(:topic, nil) == "classification"

  puts("Classification response completed: #{event.response.status}")
  Array(event.response.output).each do |item|
    next unless item.is_a?(OpenAI::Realtime::RealtimeConversationItemAssistantMessage)

    item.content.each do |content|
      puts("Classification: #{content.text}") if content.type == :output_text
    end
  end
  true
end
raise "Connection closed before the response completed" unless response_done

Crie um contexto personalizado para as respostas

Você também pode criar um contexto personalizado, fora da conversa padrão atual, para o modelo usar ao gerar uma resposta. Para isso, use o array input em um evento response.create do cliente. Você pode fornecer novas entradas ou referenciar pelo ID os itens de entrada que já estão na conversa.

Escute a resposta fora de banda do modelo com contexto personalizado

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45const existingItemId = "item_pizza";
ws.send(
  JSON.stringify({
    type: "conversation.item.create",
    item: {
      id: existingItemId,
      type: "message",
      role: "user",
      content: [
        { type: "input_text", text: "We are ordering pizza for dinner." },
      ],
    },
  })
);
const event = {
  type: "response.create",
  response: {
    conversation: "none",
    metadata: { topic: "pizza" },
    output_modalities: ["text"],

    // Create a custom input array for this request with whatever context
    // is appropriate
    input: [
      // potentially include existing conversation items:
      {
        type: "item_reference",
        id: existingItemId,
      },
      {
        type: "message",
        role: "user",
        content: [
          {
            type: "input_text",
            text: "Is it okay to put pineapple on pizza?",
          },
        ],
      },
    ],
  },
};

// WebRTC data channel and WebSocket both have .send()
ws.send(JSON.stringify(event));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46import json

existing_item_id = "item_pizza"
ws.send(
    json.dumps(
        {
            "type": "conversation.item.create",
            "item": {
                "id": existing_item_id,
                "type": "message",
                "role": "user",
                "content": [
                    {"type": "input_text", "text": "We are ordering pizza for dinner."}
                ],
            },
        }
    )
)

event = {
    "type": "response.create",
    "response": {
        "conversation": "none",
        "metadata": {"topic": "pizza"},
        "output_modalities": ["text"],
        # Create a custom input array for this request with whatever
        # context is appropriate
        "input": [
            # potentially include existing conversation items:
            {"type": "item_reference", "id": existing_item_id},
            # include new content as well
            {
                "type": "message",
                "role": "user",
                "content": [
                    {
                        "type": "input_text",
                        "text": "Is it okay to put pineapple on pizza?",
                    }
                ],
            },
        ],
    },
}

ws.send(json.dumps(event))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34existing_item_id = "item_order"
connection.conversation.items.create(
  id: existing_item_id,
  type: :message,
  role: :user,
  content: [
    {
      type: :input_text,
      text: "Order ORD-123 has not arrived."
    }
  ]
)

connection.response.create(
  conversation: :none,
  metadata: { topic: "classification" },
  output_modalities: [:text],
  input: [
    {
      type: :item_reference,
      id: existing_item_id
    },
    {
      type: :message,
      role: :user,
      content: [
        {
          type: :input_text,
          text: "Classify this issue: my order is late."
        }
      ]
    }
  ]
)

Crie respostas sem contexto

Você também pode inserir respostas na conversa padrão ignorando todas as demais instruções e todo o contexto. Para isso, defina input como um array vazio.

Insira respostas do modelo sem contexto na conversa padrão

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18const prompt = `
Say exactly the following:
I'm a little teapot, short and stout!
This is my handle, this is my spout!
`;

  const event = {
    type: "response.create",
    response: {
      // An empty input array removes existing context
      input: [],
      output_modalities: ["text"],
      instructions: prompt,
    },
  };

  // WebRTC data channel and WebSocket both have .send()
  ws.send(JSON.stringify(event));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17prompt = """
Say exactly the following:
I'm a little teapot, short and stout!
This is my handle, this is my spout!
"""

event = {
    "type": "response.create",
    "response": {
        "output_modalities": ["text"],
        # An empty input array removes all prior context
        "input": [],
        "instructions": prompt,
    },
}

ws.send(json.dumps(event))

1
2
3
4
5
6
7
8
9
10
11if err := conn.Send(ctx, realtime.RealtimeClientEventUnionParam{
	OfResponseCreate: &realtime.ResponseCreateEventParam{
		Response: realtime.RealtimeResponseCreateParams{
			Instructions:     openai.String("\nSay exactly the following:\nI'm a little teapot, short and stout!\nThis is my handle, this is my spout!\n"),
			Input:            []realtime.ConversationItemUnionParam{},
			OutputModalities: []string{"text"},
		},
	},
}); err != nil {
	return err
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18import com.openai.client.okhttp.OkHttpClient;
import com.openai.core.ClientOptions;
import com.openai.helpers.RealtimeConnection;
import com.openai.helpers.RealtimeWebSocketOptions;
import com.openai.models.realtime.*;
import java.util.List;

connection.send(
    RealtimeClientEvent.ofResponseCreate(
        ResponseCreateEvent.builder()
            .response(
                RealtimeResponseCreateParams.builder()
                    .addOutputModality(RealtimeResponseCreateParams.OutputModality.TEXT)
                    .input(List.of())
                    .instructions(
                        "Say exactly the following: I'm a little teapot, short and stout! This is my handle, this is my spout!")
                    .build())
            .build()));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17using OpenAI.Realtime;

#pragma warning disable OPENAI002

RealtimeResponseOptions options = new()

{
    OutputModalities = { RealtimeOutputModality.Text },
    Instructions = "Say exactly the following: I'm a little teapot, short and stout! This is my handle, this is my spout!"

};
options.InputItems.Clear();
// An explicitly empty list excludes conversation context.
await session.SendCommandAsync(new RealtimeClientCommandResponseCreate
{
    ResponseOptions = options
}, timeout.Token);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15connection.response.create(
  input: [],
  output_modalities: [:text],
  instructions: "Generate a concise greeting without conversation context."
)

response_done = connection.find do |event|
  raise event.error.message if event.is_a?(OpenAI::Realtime::RealtimeErrorEvent)
  next unless event.is_a?(OpenAI::Realtime::ResponseDoneEvent)

  raise "Response failed: #{event.response.status}" unless event.response.status == :completed

  true
end
raise "Connection closed before the response completed" unless response_done

Chamada de função

Os modelos Realtime também oferecem o recurso de chamada de função, que permite executar código personalizado para ampliar os recursos do modelo. O processo tem quatro etapas.

Ao atualizar a sessão ou criar uma resposta, você pode especificar uma lista de funções que o modelo pode chamar.
Se, ao processar a entrada, o modelo determinar que deve chamar uma função, ele adicionará à conversa itens que representam os argumentos da chamada.
Quando o cliente detectar itens da conversa com argumentos de uma chamada de função, executará o código personalizado com esses argumentos.
Após a execução do código, o cliente criará itens na conversa com o resultado da chamada de função e pedirá ao modelo que responda.

Para ver como isso funciona na prática, vamos adicionar uma função que o modelo pode chamar para fornecer o horóscopo do dia aos usuários. Os exemplos mostram a estrutura dos eventos que o cliente precisa enviar e o que o servidor emite em seguida.

Configure as funções que o modelo pode chamar

Primeiro, forneça ao modelo as funções que ele pode chamar com base na entrada do usuário. Você pode configurar as funções disponíveis para toda a sessão ou para uma resposta específica.

Para a sessão, use a propriedade session.tools em session.update.
Para a resposta, use a propriedade response.tools em response.create.

O exemplo a seguir mostra o conteúdo de um evento session.update do cliente que configura uma função para gerar horóscopos. A função recebe um único argumento, o signo para o qual deve gerar o horóscopo.

session.update

12345678910111213141516171819202122232425262728293031323334353637{
  "type": "session.update",
  "session": {
    "tools": [
      {
        "type": "function",
        "name": "generate_horoscope",
        "description": "Give today's horoscope for an astrological sign.",
        "parameters": {
          "type": "object",
          "properties": {
            "sign": {
              "type": "string",
              "description": "The sign for the horoscope.",
              "enum": [
                "Aries",
                "Taurus",
                "Gemini",
                "Cancer",
                "Leo",
                "Virgo",
                "Libra",
                "Scorpio",
                "Sagittarius",
                "Capricorn",
                "Aquarius",
                "Pisces"
              ]
            }
          },
          "required": ["sign"]
        }
      }
    ],
    "tool_choice": "auto"
  }
}

Os campos description da função e dos parâmetros ajudam o modelo a decidir se deve chamar a função e quais dados incluir em cada parâmetro. Se a entrada indicar que o usuário quer saber seu horóscopo, o modelo chamará a função com o parâmetro sign.

Identifique quando o modelo quer chamar uma função

Com base nas entradas recebidas, o modelo pode decidir chamar uma função para gerar a melhor resposta. Suponha que o aplicativo adicione o item a seguir à conversa com um evento conversation.item.create e depois crie uma resposta.

12345678910111213{
  "type": "conversation.item.create",
  "item": {
    "type": "message",
    "role": "user",
    "content": [
      {
        "type": "input_text",
        "text": "What is my horoscope? I am an aquarius."
      }
    ]
  }
}

Em seguida, o cliente envia um evento response.create para gerar a resposta.

123{
  "type": "response.create"
}

Em vez de retornar imediatamente uma resposta em texto ou áudio, o modelo gera uma resposta com os argumentos que o aplicativo do desenvolvedor deve passar à função. Você pode acompanhar as atualizações dos argumentos em tempo real pelo evento response.function_call_arguments.delta do servidor. O evento response.done também contém todos os dados necessários para chamar a função.

response.done

123456789101112131415161718192021{
  "type": "response.done",
  "event_id": "event_AeqLA8iR6FK20L4XZs2P6",
  "response": {
    "object": "realtime.response",
    "id": "resp_AeqL8XwMUOri9OhcQJIu9",
    "status": "completed",
    "status_details": null,
    "output": [
      {
        "object": "realtime.item",
        "id": "item_AeqL8gmRWDn9bIsUM2T35",
        "type": "function_call",
        "status": "completed",
        "name": "generate_horoscope",
        "call_id": "call_sHlR7iaFwQ2YQOqm",
        "arguments": "{\"sign\":\"Aquarius\"}"
      }
    ]
  }
}

As propriedades do JSON enviado pelo servidor permitem identificar que o modelo quer chamar uma função personalizada.

Propriedade	Papel na chamada de função
`response.output[0].type`	Quando tem o valor `function_call`, indica que a resposta contém argumentos para chamar uma função identificada pelo nome.
`response.output[0].name`	Nome da função configurada que deve ser chamada. Neste caso, `generate_horoscope`.
`response.output[0].arguments`	String JSON com os argumentos da função. Neste caso, `"{\"sign\":\"Aquarius\"}"`.
`response.output[0].call_id`	ID que o sistema gera para esta chamada de função. Você precisa desse ID para devolver o resultado da chamada ao modelo.

Com essas informações, o aplicativo pode executar o código que gera o horóscopo e devolver o resultado ao modelo para que ele gere uma resposta.

Forneça ao modelo o resultado de uma chamada de função

Ao receber uma resposta do modelo com os argumentos de uma chamada de função, o aplicativo pode executar o código que implementa a função. Esse código pode realizar as operações que você precisar, como consultar APIs externas ou acessar bancos de dados.

Quando o código personalizado produzir o resultado, você pode fornecê-lo ao modelo criando um item na conversa com o evento conversation.item.create do cliente.

12345678{
  "type": "conversation.item.create",
  "item": {
    "type": "function_call_output",
    "call_id": "call_sHlR7iaFwQ2YQOqm",
    "output": "{\"horoscope\": \"You will soon meet a new friend.\"}"
  }
}

O tipo do item da conversa é function_call_output.
item.call_id é o mesmo ID recebido no evento response.done acima.
item.output é uma string JSON que contém o resultado da chamada de função.

Depois de adicionar à conversa o item com o resultado da chamada de função, envie novamente o evento response.create pelo cliente. Isso faz com que o modelo gere uma resposta usando os dados da chamada de função.

123{
  "type": "response.create"
}

Tratamento de erros

O servidor emite o evento error sempre que encontra um erro durante a sessão. Em alguns casos, é possível identificar o evento do cliente enviado pelo aplicativo que causou o erro.

No HTTP, cada resposta está implicitamente associada a uma solicitação do cliente. Na Realtime API, use a propriedade event_id nos eventos do cliente para identificar qual deles causou um erro no servidor. No exemplo abaixo, o cliente tenta emitir um evento de um tipo sem suporte.

1
2
3
4
5
6const event = {
  event_id: "my_awesome_event",
  type: "scooby.dooby.doo",
};

dataChannel.send(JSON.stringify(event));

Ao receber esse evento inválido do cliente, o servidor emite um evento de erro como o do exemplo abaixo.

1234567891011{
  "type": "error",
  "event_id": "event_error_123",
  "error": {
    "type": "invalid_request_error",
    "code": "invalid_value",
    "message": "Invalid value: 'scooby.dooby.doo'.",
    "param": "type",
    "event_id": "my_awesome_event"
  }
}

Interrupção e truncamento

Em muitos aplicativos de voz, o usuário pode interromper o modelo enquanto ele fala. Quando a VAD está ativada, a Realtime API detecta a fala do usuário, cancela a resposta em andamento e inicia outra. Para continuar a conversa naturalmente, o modelo precisa saber em que ponto foi interrompido, por exemplo, se o usuário perguntar “o que você acabou de dizer?”. Truncar a última resposta do modelo significa remover da conversa o trecho dessa resposta que não foi reproduzido.

Nas conexões WebRTC e SIP, o servidor gerencia um buffer de áudio de saída e sabe quanto áudio já foi reproduzido a cada momento. Quando o usuário interrompe o modelo, o servidor remove automaticamente o áudio que ainda não foi reproduzido.

Nas conexões WebSocket, o cliente gerencia a reprodução do áudio. Por isso, cabe a ele interromper a reprodução e truncar a resposta.

Ao receber input_audio_buffer.speech_started, interrompa imediatamente a reprodução do áudio do modelo e descarte o áudio desse item que ainda estiver na fila. Registre quantos milissegundos de áudio do item o usuário realmente ouviu.
Envie um evento conversation.item.truncate com o ID do item interrompido, o índice do conteúdo de áudio e a duração já reproduzida em audio_end_ms. Isso remove da conversa o trecho que não foi reproduzido.
Quando a VAD interrompe uma resposta em andamento, o servidor cancela a resposta e envia response.done com response.status definido como cancelled. Use esse evento para identificar o término da resposta. Interrompa a reprodução e envie o evento de truncamento sem esperar por ele.

Veja um exemplo.

123456{
  "type": "conversation.item.truncate",
  "item_id": "item_1234",
  "content_index": 0,
  "audio_end_ms": 1500
}

O exemplo trunca o áudio após 1,5 segundo de reprodução.

E a transcrição? O modelo Realtime não dispõe de informações suficientes para alinhar com precisão a transcrição e o áudio. Por isso, conversation.item.truncate corta o áudio no ponto indicado e remove o texto da transcrição referente ao trecho que não foi reproduzido. Isso elimina o áudio que o usuário não ouviu, mas não fornece uma transcrição truncada.

Pressionar para falar

Por padrão, a Realtime API usa a detecção de atividade de voz (VAD) para acionar respostas do modelo a partir do áudio de entrada. Você também pode implementar a interação de pressionar para falar. Para isso, desative a VAD e controle pelo aplicativo quando enviar o áudio de entrada ao modelo. Por exemplo, o aplicativo pode capturar áudio enquanto o usuário mantém a barra de espaço pressionada e acionar uma resposta quando ele solta a tecla. Em alguns aplicativos, essa abordagem funciona muito bem. Ela dá ao usuário o controle da interação, evita falhas de detecção da VAD e torna a resposta mais rápida porque o aplicativo não precisa aguardar o tempo limite da VAD.

A implementação desse recurso varia entre WebSockets e WebRTC. Em uma conexão WebSocket com a Realtime API, todos os eventos passam pelo mesmo canal, na ordem em que foram enviados. Já uma conexão WebRTC usa canais separados para áudio e eventos de controle.

WebSockets

Para implementar o recurso de pressionar para falar em uma conexão WebSocket, configure o cliente para parar a reprodução de áudio, tratar interrupções e iniciar uma nova resposta.

Desative a VAD definindo "turn_detection": null em um evento session.update.
Quando o usuário pressionar o botão, comece a gravar o áudio no cliente.
1. Se o modelo estiver gerando uma resposta, cancele-a enviando um evento response.cancel.
2. Se o áudio do modelo estiver sendo reproduzido, interrompa a reprodução imediatamente e envie um evento conversation.item.truncate para remover da conversa o áudio que ainda não foi reproduzido.
Quando o usuário soltar o botão, envie uma mensagem input_audio_buffer.append com o áudio gravado para adicioná-lo ao buffer de entrada.
Envie um evento input_audio_buffer.commit para confirmar o áudio gravado no buffer de entrada e iniciar a transcrição da entrada, se ela estiver habilitada.
Em seguida, acione uma resposta com um evento response.create.

WebRTC e SIP

A implementação do recurso de pressionar para falar com WebRTC é semelhante, mas exige que você limpe explicitamente o buffer de áudio de entrada.

Desative a VAD definindo "turn_detection": null em um evento session.update.
Quando o usuário pressionar o botão, envie um evento input_audio_buffer.clear para limpar o áudio de entrada anterior.
1. Se o modelo estiver gerando uma resposta, cancele-a enviando um evento response.cancel.
2. Se o áudio do modelo estiver sendo reproduzido, envie um evento output_audio_buffer.clear para descartar o áudio que ainda não foi reproduzido. Esse evento também trunca a conversa.
Quando o usuário soltar o botão, envie um evento input_audio_buffer.commit para confirmar o áudio gravado no buffer de entrada e iniciar a transcrição da entrada, se ela estiver habilitada.
Em seguida, acione uma resposta com um evento response.create.

Sugestões

Primeiros passos

Conceitos fundamentais

SDKs e CLI

Provedores de nuvem

Recursos

APIs legadas

Escolha um modelo

Texto e código

Como escrever prompts

Raciocínio

Imagens

Tempo real e áudio

Modelos especializados

API de agentes

SDK de agentes

ChatKit

Busca e recuperação de informações

Conecte ferramentas e dados

Crie fluxos de trabalho com ferramentas

Computador e código

Mídia

GPT-Live

Realtime API

Desenvolver aplicações de voz

Conexões

Processamento de áudio

Coloque em produção

Desempenho e qualidade

Avaliação

Custo e taxa de processamento

Segurança e governança

Infraestrutura e acesso

Operações

Conceitos fundamentais

Planejar

Desenvolver

Testar e publicar

Especificações de conversão

Guias

Recursos

Identidade

Uso do plano do ChatGPT

Guias

Envio de arquivos

API

Mensuração

API para anunciantes

Referência da API

Primeiros passos

Primeiros passos

Fundamentos

Explorar

Disponível em

Versões

Fluxos de trabalho

Capacidades

Sites

dots

ChatGPT Space

Referência

Personalização

Arquivo de configuração

Configuração de agentes

Ampliar os recursos do ChatGPT e do Codex

Linux

Windows

Fluxos de trabalho de desenvolvimento

Ampliar recursos e automatizar tarefas

Ambientes

Codex Cloud

Desenvolver com o Codex

Integrações de terceiros

Referência

Permissões

Codex Security

Segurança cibernética

Primeiros passos

Configuração de recursos

Identidade e acesso