Migre para o GPT-Live

Migração da Realtime API

Comece pelo guia de prompts do GPT-Live. Divida o prompt existente entre o modelo de voz e o backend, em vez de copiá-lo por inteiro para session.instructions. Mantenha o estilo de conversa e as orientações de delegação no prompt de voz. Transfira os fluxos de trabalho detalhados e as instruções de uso das ferramentas para o backend.

Antes: o modelo Realtime cuida da fala e seleciona funções como check_availability e book_appointment. O aplicativo executa as funções e retorna os resultados.

Depois: o GPT-Live cuida da fala e delega a execução das tarefas. O backend seleciona as mesmas funções, e o aplicativo continua responsável por validá-las e executá-las. As etapas a seguir usam a delegação via Responses. Se você mantiver um agente externo, use o adaptador do cliente.

Como funciona a delegação via Responses

Configure o modelo de backend, as instruções e as ferramentas em delegation.responses. Quando o GPT-Live determina que uma solicitação precisa do backend, o serviço Live chama o modelo do Responses configurado e fornece o contexto relevante da conversa. O backend analisa a tarefa e seleciona as ferramentas. O aplicativo continua responsável por executar as funções personalizadas, aplicar as permissões e retornar os resultados.

No exemplo do assistente de agendamento:

1. O usuário pergunta quais horários estão disponíveis na sexta-feira, e o GPT-Live delega a solicitação.
2. O backend do Responses solicita check_availability.
3. O aplicativo executa a função, retorna o resultado e dá continuidade à resposta do backend.
4. O GPT-Live usa a resposta do backend para conversar com o usuário sobre os horários disponíveis.

O GPT-Live pode continuar falando enquanto o backend trabalha. Acompanhe a tarefa do backend e a reprodução do áudio separadamente. Use os resultados das ferramentas para atualizar o status da tarefa e o estado do reprodutor de áudio para atualizar o indicador de fala. Consulte Delegação e ferramentas para ver a configuração e o fluxo completo de eventos.

Adapte a conexão e o ciclo de vida do áudio

Substitua a configuração de sessão do Realtime pelo procedimento de conexão do GPT-Live. Verifique novamente como o transporte é iniciado e qual formato de áudio ele usa. O WebRTC transmite o áudio pelas trilhas de mídia e os eventos JSON pelo canal de dados. Uma conexão WebSocket primária transmite o áudio em eventos JSON.

Se o aplicativo Realtime usa uma conexão com o servidor para monitorar a chamada ou aplicar mecanismos de proteção, adapte-a para usar a conexão auxiliar do GPT-Live. Siga as orientações em Adapte seus mecanismos de proteção para ajustar as verificações da conversa e a reprodução.

Geração e reprodução: Use o estado do reprodutor de áudio para controlar o indicador de fala. O servidor pode terminar de gerar o áudio quando ainda resta um segundo na fila de reprodução. No Realtime, response.output_audio.done marca o fim da geração e response.done encerra o fluxo da resposta. Consulte response.status para identificar interrupções ou falhas. O GPT-Live não tem um evento equivalente para o fim de cada resposta falada.

Legendas: Quando a transcrição da entrada está habilitada, o Realtime envia fragmentos de texto por conversation.item.input_audio_transcription.delta e a transcrição final por conversation.item.input_audio_transcription.completed. No GPT-Live, acrescente cada fragmento às legendas de quem ligou ou às do assistente, conforme quem falou. Os dois conjuntos de legendas podem mudar ao mesmo tempo. O aplicativo decide como agrupar o texto e acompanha a reprodução pelo reprodutor de áudio. Consulte Exiba legendas.

Use response.create para iniciar ou continuar uma tarefa delegada ao Responses. O GPT-Live decide quando falar enquanto escuta a conversa. Para iniciar a sessão, fazer a saudação, lidar com interrupções e encerrar a sessão, siga as orientações em Gerenciamento de sessões.

Separe as instruções de conversa das instruções do backend

Ao migrar um assistente Realtime para o GPT-Live, comece pelo prompt existente. Mova as instruções sobre o estilo de fala e a alternância de turnos para o prompt do Live e acrescente regras sobre quando delegar. Mantenha as instruções das tarefas e os procedimentos de uso das ferramentas no prompt do backend.

Se estiver adicionando voz a um agente de texto, reaproveite o prompt existente do backend e escreva um prompt do Live para a interação por voz.

Mantenha a experiência consistente

Mantenha o papel, o público e o propósito do assistente e preserve os detalhes que orientam a conversa:

• Saudações, apresentações e avisos falados, incluindo qualquer exigência de redação ou ordem.
• Requisitos de idioma e pronúncia, como “Fale em inglês”.
• Personalidade, cordialidade, empatia, formalidade e ritmo.
• O nível de detalhe das respostas faladas e os exemplos que demonstram o estilo pretendido.
• Como o assistente sinaliza que está ouvindo o usuário, faz pausas para escutar e responde a interrupções.

Mesmo um prompt curto do Live pode pedir respostas faladas detalhadas.

Escreva o prompt do Live

Use a estrutura de prompt recomendada para definir a identidade, o estilo de fala e o comportamento do assistente durante a conversa. Mantenha Backchannel policy e Interruption policy para descrever como o assistente sinaliza que está ouvindo e como reage quando alguém começa a falar enquanto ele ainda está falando.

O Live precisa conhecer os recursos do backend para delegar corretamente. Descreva esses recursos em linguagem simples. Mantenha os nomes das funções e os schemas das ferramentas no backend, que cuida das chamadas de ferramentas.

Em Delegation policy, adapte estas seções ao aplicativo:

• Backend tools: Liste os recursos que o aplicativo oferece usando os mesmos termos do prompt existente. Por exemplo: “Verificar a disponibilidade de horários e agendar ligações de retorno”.
• Delegate to the backend when: Indique quando usar esses recursos, por exemplo: “Delegue quando o usuário pedir para agendar uma ligação de retorno”. Inclua correções, confirmações e novos detalhes necessários para tarefas já em andamento.
• Do not delegate to the backend when: Descreva o que o Live pode fazer diretamente, como cumprimentar o usuário, pedir um esclarecimento breve ou repetir informações da conversa ou de um resultado do backend que ainda seja válido.

Descreva como o Live deve comunicar o progresso, fazer a próxima pergunta indicada pelo backend ou transmitir um resultado verificado.

Se o assistente encerra chamadas, inclua no prompt do Live instruções para se despedir e delegar a solicitação de encerramento. Coloque no backend a ferramenta que encerra a chamada e a sequência de etapas a seguir. Por exemplo, um procedimento pode exigir que o aplicativo termine de reproduzir a despedida, desconecte a chamada, cancele cálculos pendentes e impeça que novos dados sejam salvos. O Live cuida da despedida e da delegação. O backend e o aplicativo executam as etapas restantes.

Adapte o prompt do backend

Use o prompt original como ponto de partida. Mantenha a redação, a ordem, os exemplos e a estrutura sempre que ainda se aplicarem. Se o prompt descreve principalmente tarefas, a maior parte pode permanecer como está.

Mantenha no backend as instruções para:

• Interpretar a solicitação do usuário, aplicar correções, coletar informações que faltam e acompanhar o progresso da tarefa.
• Usar informações do domínio, verificar a elegibilidade e consultar os registros ou serviços que fundamentam a resposta.
• Seguir os procedimentos de busca, atualização, confirmação, encaminhamento, transferência, ligação de retorno e outras ações disponíveis.
• Aplicar regras de segurança, privacidade e autorização, lidar com falhas e restringir ações após a transferência ou o encerramento da chamada.
• Preparar informações precisas sobre os fatos e o status da tarefa, além da próxima pergunta que o Live deve fazer.

Mova as instruções sobre voz, saudações, alternância de turnos e quando delegar para o prompt do Live. Adapte as instruções que pressupõem que o backend fala diretamente com o usuário para que ele retorne as informações ao Live. Mantenha os limites de segurança e privacidade nos dois prompts sempre que afetarem o que o respectivo modelo pode dizer, perguntar ou fazer.

Mantenha os nomes das funções, os requisitos dos argumentos e os procedimentos de uso das ferramentas nas instruções do backend. Coloque as definições das ferramentas na configuração de ferramentas do backend. O aplicativo executa as ferramentas, verifica as permissões, valida os argumentos e exige as confirmações necessárias com base no estado atual da tarefa.

Use o modelo de backend para interpretar solicitações, correções e confirmações no contexto da conversa. Expressões regulares, listas de palavras-chave e regras de correspondência exata de frases não captam sentidos que dependem de uma fala anterior ou de uma correção. Por exemplo, “sim” pode confirmar um horário, indicar que a pessoa ouviu uma pergunta ou se referir a uma sugestão anterior.

Preserve as regras para tarefas já em andamento quando quem ligou interrompe o assistente ou quando a chamada é transferida ou encerrada. Interromper a fala não interrompe as tarefas do backend. Se a pessoa pedir o cancelamento, o backend e o aplicativo precisam processar o pedido e informar o resultado ao Live.

Resolva conflitos entre instruções

Revise o prompt original e os dois novos prompts em busca de instruções conflitantes. Combine instruções repetidas e mantenha as condições específicas e as exceções junto das regras às quais se aplicam. Verifique as permissões, os limites de perguntas, as confirmações e o que pode acontecer após o encerramento de uma chamada.

Diferencie o que o usuário quer do que já aconteceu. Se a pessoa trocar sexta-feira por quinta-feira, a solicitação mais recente indica ao backend que ele deve considerar a quinta-feira. O registro da reserva indica se o horário de sexta-feira já foi reservado. As regras existentes de confirmação e autorização determinam quais alterações o backend pode fazer em seguida.

Antes de usar os prompts, alinhe as decisões de produto com os responsáveis. Por exemplo, se uma instrução manda prosseguir com a reserva e outra manda interromper todas as tarefas quando a pessoa interrompe o assistente, decida como o aplicativo deve se comportar. Registre o comportamento acordado nos prompts e implemente-o na lógica do aplicativo.

Verifique se cada ação obrigatória está implementada. Para encerrar uma chamada, é preciso ter um recurso de encerramento. Se o assistente apenas se despedir, a conexão continuará aberta. Se faltar um recurso, decida se vai implementá-lo ou combinar uma alternativa compatível com a equipe responsável pelo fluxo de trabalho.

Revise os dois prompts

Compare os dois prompts com o original e verifique se eles contemplam todos os comportamentos exigidos:

• O prompt do Live preserva a identidade, o vocabulário, o estilo de fala, os avisos e a reação do assistente a interrupções.
• O prompt do backend preserva os procedimentos das tarefas, os fatos, as condições, os exemplos, as permissões e o tratamento de falhas.
• A delegação abrange novas solicitações, correções, confirmações e solicitações que combinam diálogo com informações da tarefa.
• Os dois prompts estabelecem os mesmos limites de perguntas, os mesmos critérios de confirmação de ações e as mesmas regras para tarefas em andamento, cancelamentos, transferências e encerramento de chamadas.

Coloque o prompt do Live em session.instructions. Para a delegação via Responses, coloque o prompt do backend em session.delegation.responses.instructions. Para a delegação via cliente, mantenha-o na configuração do agente existente. Mantenha as definições das ferramentas no backend. Consulte Delegação e ferramentas para saber como configurar a delegação e tratar os resultados.

You are Rowan, the appointment assistant for Northstar Repairs.
Speak English, calmly and briefly. Greet the caller once with:
"Hello, this is Rowan from Northstar Repairs. How can I help?"
Use brief listening acknowledgments. Stop speaking when interrupted.

Help callers find and book appointments. Ask for the preferred date
and time zone if missing, then use check_availability.
Offer only returned slots. Ask the caller to confirm the exact slot
before calling book_appointment.
If the caller changes the date, time zone, or slot, discard the earlier
confirmation and check availability again.
Report a booking only after the tool confirms success. If the outcome
is unclear, say it is unconfirmed and do not retry automatically.

You are Rowan, the appointment assistant for Northstar Repairs.
Speak English, calmly and briefly. Greet the caller once with:
"Hello, this is Rowan from Northstar Repairs. How can I help?"

Backchannel policy: Use brief listening acknowledgments.

Interruption policy: Stop speaking when interrupted and listen.

Delegation policy:
Backend tools:
- Appointments: check available times and book appointments.

Delegate to the backend when:
- The caller wants to find or book an appointment.
- The caller supplies or corrects a date, time zone, or slot, or
  answers a booking question, including confirming a slot.

Do not delegate to the backend when:
- The caller greets you or asks you to repeat a still-current result.
- You need a brief clarification to understand what they are asking.

Relay the backend's questions and results. Offer only slots it returns.
Do not claim a booking is complete until the backend confirms success.
If the backend reports an unclear outcome, say it is unconfirmed.

Help callers find and book appointments for Northstar Repairs.
Ask for the preferred date and time zone if missing, then use
check_availability. Offer only returned slots.
Ask the caller to confirm the exact slot before calling book_appointment.
If the caller changes the date, time zone, or slot, discard the earlier
confirmation and check availability again.
Report a booking only after the tool confirms success. If the outcome
is unclear, report it as unconfirmed and do not retry automatically.

Return the available slots, booking outcome, or next question for the
voice assistant to communicate. Interpret the caller's latest answers
and corrections using the conversation and current task state.

Adapte o tratamento das chamadas de função

Mantenha a implementação de check_availability e book_appointment. Mova as definições dessas funções de session.tools ou response.tools do Realtime para delegation.responses.tools, usando o schema de funções do Responses. Mova as configurações de seleção de ferramentas para delegation.responses.tool_choice e delegation.responses.parallel_tool_calls. Consulte Configure a delegação via Responses.

A função continua retornando um resultado associado ao call_id original. O que muda é por onde a rotina que trata a chamada recebe a solicitação e envia o resultado:

Por exemplo, depois que check_availability retornar um horário verificado, envie o evento a seguir pela sessão conectada. Substitua call_availability pelo ID da chamada que você recebeu.

Antes: resultado no Realtime

12345678{
  "type": "conversation.item.create",
  "item": {
    "type": "function_call_output",
    "call_id": "call_availability",
    "output": "{\"available\":true,\"slot_id\":\"slot_friday_14\",\"booked\":false}"
  }
}

Depois: resultado no GPT-Live

1
2
3
4
5
6
7
8
9
10
11export function sendUpdate(connection) {
  connection.send({
    type: "response.item.create",
    event_id: "availability_result_1",
    item: {
      type: "function_call_output",
      call_id: "call_availability",
      output: '{"available":true,"slot_id":"slot_friday_14","booked":false}',
    },
  });
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17from openai.resources.live.live import AsyncLiveConnection
from openai.resources.live.sideband import AsyncSidebandConnection
from openai.types.responses.response_input_item_param import ResponseInputItemParam


async def send_update(
    connection: AsyncLiveConnection | AsyncSidebandConnection,
) -> None:
    item: ResponseInputItemParam = {
        "type": "function_call_output",
        "call_id": "call_availability",
        "output": '{"available":true,"slot_id":"slot_friday_14","booked":false}',
    }
    await connection.response.item.create(
        event_id="availability_result_1",
        item=item,
    )

1
2
3
4
5
6
7
8
9
10
11
12
13
14import (
	"context"
	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/live"
	"github.com/openai/openai-go/v3/responses"
)

// SendUpdate requires a started Live session.
func SendUpdate(ctx context.Context, connection *live.LiveConnection) error {
	return connection.Send(ctx, live.ClientEventUnionParam{OfResponseItemCreate: &live.ResponseItemCreateEventParam{
		EventID: openai.String("availability_result_1"),
		Item:    responses.ResponseInputItemUnionParam{OfFunctionCallOutput: &responses.ResponseInputItemFunctionCallOutputParam{CallID: openai.String("call_availability"), Output: responses.ResponseInputItemFunctionCallOutputOutputUnionParam{OfString: openai.String("{\"available\":true,\"slot_id\":\"slot_friday_14\",\"booked\":false}")}}},
	}})
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17import com.openai.helpers.LiveConnection;
import com.openai.models.live.*;
import com.openai.models.responses.*;

public static void sendUpdate(LiveConnection connection) {
  connection.send(
      ClientEvent.ofResponseItemCreate(
          ResponseItemCreateEvent.builder()
              .eventId("availability_result_1")
              .item(
                  ResponseInputItem.FunctionCallOutput.builder()
                      .callId("call_availability")
                      .output(
                          "{\"available\":true,\"slot_id\":\"slot_friday_14\",\"booked\":false}")
                      .build())
              .build()));
}

1
2
3
4
5
6
7
8
9def send_update(connection)
  connection.send_event(
    type: "response.item.create", event_id: "availability_result_1", item: {
      type: "function_call_output",
      call_id: "call_availability",
      output: "{\"available\":true,\"slot_id\":\"slot_friday_14\",\"booked\":false}"
    }
  )
end

Depois de enviar todos os resultados de função necessários, dê continuidade à tarefa do backend:

1
2
3
4
5
6export function sendUpdate(connection) {
  connection.send({
    type: "response.create",
    event_id: "continue_availability_1",
  });
}

1
2
3
4
5
6
7
8
9
10from openai.resources.live.live import AsyncLiveConnection
from openai.resources.live.sideband import AsyncSidebandConnection


async def send_update(
    connection: AsyncLiveConnection | AsyncSidebandConnection,
) -> None:
    await connection.response.create(
        event_id="continue_availability_1",
    )

1
2
3
4
5
6
7
8
9
10
11
12import (
	"context"
	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/live"
)

// SendUpdate requires a started Live session.
func SendUpdate(ctx context.Context, connection *live.LiveConnection) error {
	return connection.Send(ctx, live.ClientEventUnionParam{OfResponseCreate: &live.ResponseCreateEventParam{
		EventID: openai.String("continue_availability_1"),
	}})
}

1
2
3
4
5
6
7
8import com.openai.helpers.LiveConnection;
import com.openai.models.live.*;

public static void sendUpdate(LiveConnection connection) {
  connection.send(
      ClientEvent.ofResponseCreate(
          ResponseCreateEvent.builder().eventId("continue_availability_1").build()));
}

1
2
3def send_update(connection)
  connection.send_event(type: "response.create", event_id: "continue_availability_1")
end

Na migração inicial, defina parallel_tool_calls como false para tratar uma chamada de ferramenta por vez. Obtenha cada chamada de função do evento interno response.output_item.done e guarde o nome, os argumentos e o call_id. Mantenha esse registro mesmo que um evento de conclusão posterior contenha output: []. Aguarde o item completo antes de executar o código que trata a chamada. O evento que indica a conclusão dos argumentos, por si só, não contém o nome da função nem o call_id. Siga o procedimento completo para resultados de funções para coletar as chamadas, enviar os resultados e tratar erros.

Preserve o contexto e aplique correções

Na delegação via Responses, o backend recebe o contexto relevante da conversa por voz. Mantenha no aplicativo o registro oficial do estado do agendamento: horário selecionado, horário confirmado, permissões, operação em andamento e resultado. O histórico de conversa do Live pode ser compactado e não substitui o registro da reserva.

Quando o usuário disser “Na verdade, prefiro sexta-feira”, registre sexta-feira como a solicitação atual e remova qualquer confirmação referente à quinta-feira. Atribua à tarefa um novo número de versão, por exemplo, revisão 2, para que o aplicativo reconheça os resultados da solicitação anterior.

Antes de fazer a reserva, verifique se a data, o horário e a confirmação ainda correspondem à solicitação atual. Se você recusar uma chamada de função pendente porque o usuário mudou a solicitação, retorne um resultado que informe se a chamada foi ignorada ou cancelada, conforme o que de fato ocorreu. Envie um resultado para cada chamada obrigatória antes de dar continuidade à tarefa do backend.

Se a reserva de quinta-feira já tiver sido feita, verifique o status atual e trate a alteração solicitada antes de tentar fazer outra reserva.

Guarde cada fragmento da transcrição exatamente como foi recebido, junto com a identificação de quem falou, start_ms e end_ms. Use essas informações para atualizar a legenda ou o balão de conversa correspondente à pessoa que ligou ou ao assistente, inclusive quando um fragmento chegar com atraso ou as duas vozes se sobrepuserem. Defina no aplicativo onde começa e termina cada mensagem e acompanhe a reprodução pelo reprodutor de áudio. As marcas de tempo da transcrição não indicam o instante exato em que cada palavra é reproduzida. Quando houver dúvida sobre a intenção do usuário, peça que ele esclareça datas, nomes e números importantes. Consulte Gerenciamento de sessões para saber como lidar com transcrições e contexto.

Imagens e contexto da tela: Se o aplicativo Realtime aceita imagens, encaminhe-as a um backend capaz de interpretá-las e retorne ao GPT-Live o texto relevante. Tanto a delegação via cliente quanto a delegação via Responses permitem esse fluxo. Consulte Adicione imagens e contexto visual.

Preserve as decisões que dependem do áudio

Algumas decisões exigem o próprio som, como detectar o sinal sonoro da caixa postal ou reconhecer uma saudação gravada pelo ritmo da fala e das pausas. O GPT-Live ouve a chamada, mas a delegação não envia o áudio automaticamente ao backend. No modo cliente, session.delegation.created contém um ID e informações de tempo. O aplicativo fornece o contexto da solicitação e o áudio de que o backend precisa.

Para detectar uma secretária eletrônica, encaminhe explicitamente o áudio recebido a um detector capaz de analisá-lo. Uma arquitetura que você pode avaliar consiste em fazer o aplicativo executar uma sessão Realtime separada em paralelo com o GPT-Live durante parte da chamada:

1. Envie uma cópia do áudio recebido na chamada para cada sessão.
2. Configure o detector para informar a classificação por meio de uma chamada de função estruturada. Valide cada resultado de acordo com o schema, rejeite resultados desatualizados e mantenha a classificação como desconhecida quando não houver evidências suficientes. Permita que novas evidências alterem a decisão.
3. Envie ao GPT-Live o contexto relevante de fontes confiáveis e aplique a política do aplicativo à reprodução do áudio de saída.

Acompanhe duas decisões: se quem atendeu foi uma pessoa ou uma máquina e se o destino da chamada já está pronto para gravar sua mensagem. O detector pode reconhecer a caixa postal enquanto a saudação ainda está tocando. Aguarde as evidências exigidas pelo aplicativo antes de liberar o áudio de saída. A confirmação de recebimento do contexto indica que a atualização foi aceita. A decisão de reproduzir o áudio continua a cargo do aplicativo. Consulte Adapte seus mecanismos de proteção e use os controles de reprodução para aplicar essa decisão no fluxo de áudio controlado pelo aplicativo.

Teste uma saudação de caixa postal que começa com um breve “alô”, mensagens de triagem de chamadas e o caso de uma pessoa que atende durante a mensagem da caixa postal. Se você pretende desativar o detector antes do fim da chamada, teste o que acontece quando alguém atende depois disso. Considere os resultados e o custo adicional do detector para decidir por quanto tempo mantê-lo ativo. Inclua casos em que a classificação inicial de “humano” muda à medida que mais áudio chega.

Migração de um agente de texto ou pipeline em cascata

Antes: um agente de texto recebe solicitações por escrito e usa suas ferramentas e o estado salvo. Um pipeline de voz encadeado, ou em cascata, acrescenta uma etapa de conversão de fala em texto antes do agente e outra de conversão de texto em fala depois dele.

Depois: o GPT-Live fornece a interface de voz e delega as tarefas ao agente existente. Em um pipeline em cascata, ele substitui as etapas separadas de conversão de fala em texto e de texto em fala. Mantenha no backend os modelos, as instruções, as ferramentas, o fluxo de trabalho e o estado persistente que continuarem adequados à tarefa.

Conecte o agente existente

Configure delegation como {"type":"client"} durante a configuração da sessão. O aplicativo recebe uma notificação como esta:

123456789{
  "type": "session.delegation.created",
  "offset_ms": 1000,
  "delegation": {
    "id": "item_appointment_1",
    "type": "delegation",
    "target": "client"
  }
}

Use essa notificação para iniciar a rotina de delegação do aplicativo. Preserve delegation.id para associar o resultado à mesma solicitação. A rotina prepara a entrada do agente com base nas transcrições de quem ligou e do assistente e nos registros da tarefa mantidos pelo aplicativo. A notificação em si não contém o texto da solicitação nem os argumentos das ferramentas.

Por exemplo, o agente de agendamento poderia receber:

Pessoa que ligou: “Na verdade, prefiro sexta-feira.”

Solicitação atual: encontre um horário na sexta-feira, no fuso horário de quem ligou.

Resultado anterior: o horário oferecido foi quinta-feira às 14h.

Confirmação: nenhum horário de sexta-feira foi confirmado.

Revisão da tarefa: 2.

A notificação pode chegar antes que toda a frase seja transcrita. Guarde-a até ter contexto suficiente ou peça um esclarecimento à pessoa que ligou antes de agir.

Em um aplicativo de texto, você pode passar a mensagem mais recente do usuário diretamente ao agente. Com o GPT-Live, adicione um adaptador que forneça esse contexto e retorne um resultado conciso e verificado.

Antes de chamar o adaptador, registre o ID da delegação para garantir que apenas uma rotina inicie a tarefa correspondente. Se a solicitação não estiver clara, chame o adaptador novamente quando o contexto estiver pronto.

O backend continua responsável pela autorização, pela confirmação, pelos IDs das operações e pelas novas tentativas. Verifique a revisão atual da tarefa antes de alterar uma reserva. A verificação posterior da revisão pelo adaptador apenas impede que um resultado desatualizado seja anunciado. Ela não pode desfazer uma reserva já feita.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25async function handleDelegation(event, app) {
  if (
    event.type !== "session.delegation.created" ||
    event.delegation?.target !== "client"
  )
    return;

  const context = app.readContext();
  if (!context) return; // Retain the notice; resolve the request before acting.

  const summary = await app.runAgent({
    revision: context.revision,
    recentConversation: context.recentConversation,
    task: context.task,
  });

  if (app.currentRevision() !== context.revision) return;

  app.send({
    type: "session.commentary.append",
    event_id: crypto.randomUUID(),
    delegation_id: event.delegation.id,
    content: summary,
  });
}

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
40from collections.abc import Awaitable, Callable
from dataclasses import dataclass
from uuid import uuid4

from openai.resources.live.live import AsyncLiveConnection
from openai.resources.live.sideband import AsyncSidebandConnection
from openai.types.live.server_event import ServerEvent


@dataclass(frozen=True)
class Context:
    revision: int
    recent_conversation: str
    task: str


async def handle_delegation(
    event: ServerEvent,
    connection: AsyncLiveConnection | AsyncSidebandConnection,
    *,
    read_context: Callable[[], Context | None],
    run_agent: Callable[[Context], Awaitable[str]],
    current_revision: Callable[[], int],
) -> None:
    if (
        event.type != "session.delegation.created"
        or event.delegation.target != "client"
    ):
        return
    context = read_context()
    if context is None:
        return  # Retain the notice; resolve the request before acting.
    summary = await run_agent(context)
    if current_revision() != context.revision:
        return
    await connection.session.commentary.append(
        event_id=str(uuid4()),
        delegation_id=event.delegation.id,
        content=summary,
    )

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
34import (
	"context"
	"crypto/rand"
	"github.com/openai/openai-go/v3"
	"github.com/openai/openai-go/v3/live"
)

type Context struct {
	Revision           int
	RecentConversation string
	Task               string
}

func handleDelegation(ctx context.Context, event live.ServerEventUnion, connection *live.LiveConnection,
	readContext func() *Context, runAgent func(context.Context, Context) (string, error), currentRevision func() int) error {
	if event.Type != "session.delegation.created" || event.AsDelegationCreatedEvent().Delegation.Target != "client" {
		return nil
	}
	snapshot := readContext()
	if snapshot == nil {
		return nil
	} // Retain the notice; resolve the request before acting.
	saved := *snapshot
	summary, err := runAgent(ctx, saved)
	if err != nil {
		return err
	}
	if currentRevision() != saved.Revision {
		return nil
	}
	return connection.Send(ctx, live.ClientEventUnionParam{OfSessionCommentaryAppend: &live.CommentaryAppendEventParam{
		EventID: openai.String(rand.Text()), DelegationID: openai.String(event.AsDelegationCreatedEvent().Delegation.ID), Content: summary,
	}})
}

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
34import com.openai.helpers.LiveConnection;
import com.openai.models.live.*;
import java.util.UUID;
import java.util.concurrent.CompletionStage;
import java.util.function.*;

public record Context(int revision, String recentConversation, String task) {}

public static CompletionStage<Void> handleDelegation(
    ServerEvent event,
    LiveConnection connection,
    Supplier<Context> readContext,
    Function<Context, CompletionStage<String>> runAgent,
    IntSupplier currentRevision) {
  if (!event.isSessionDelegationCreated()
      || !event.asSessionDelegationCreated().delegation().target().toString().equals("client"))
    return java.util.concurrent.CompletableFuture.completedFuture(null);
  var snapshot = readContext.get();
  // Retain the notice; resolve the request before acting.
  if (snapshot == null) return java.util.concurrent.CompletableFuture.completedFuture(null);
  return runAgent
      .apply(snapshot)
      .thenAccept(
          summary -> {
            if (currentRevision.getAsInt() != snapshot.revision()) return;
            connection.send(
                ClientEvent.ofSessionCommentaryAppend(
                    CommentaryAppendEvent.builder()
                        .eventId(UUID.randomUUID().toString())
                        .delegationId(event.asSessionDelegationCreated().delegation().id())
                        .content(summary)
                        .build()));
          });
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18require "openai"
require "securerandom"
Context = Data.define(:revision, :recent_conversation, :task)

def handle_delegation(event, connection, read_context:, run_agent:, current_revision:)
  return unless event.type == :"session.delegation.created" && event.delegation.target == :client

  context = read_context.call
  return if context.nil? # Retain the notice; resolve the request before acting.

  summary = run_agent.call(context)
  return unless current_revision.call == context.revision

  connection.send_event(
    type: :"session.commentary.append", event_id: SecureRandom.uuid,
    delegation_id: event.delegation.id, content: summary
  )
end

Implemente no aplicativo os callbacks de contexto e do agente. O callback de contexto retorna a conversa recente e a tarefa atual ou, se a solicitação ainda não estiver clara, não retorna nenhum valor. O callback do agente executa o backend existente e retorna um resumo verificado de até 500 tokens. Em JavaScript, o callback send fornecido pelo aplicativo envia o evento JSON pela conexão Live. Em Python, o adaptador envia a atualização diretamente pela connection do SDK.

No caso do assistente de agendamento, o contexto deve indicar a data solicitada, o fuso horário, os horários oferecidos anteriormente, qualquer horário já confirmado e a correção mais recente. Um resultado de consulta de disponibilidade deve informar que o horário está disponível e que nenhuma reserva foi feita. Só retorne uma confirmação de reserva depois que ela for concluída com sucesso. Consulte Delegação via cliente para ver a configuração e o fluxo completo dos resultados.

Encaminhe atualizações e correções

Mantenha a saída estruturada das ferramentas e os detalhes do fluxo de trabalho no backend. Retorne ao GPT-Live atualizações breves e factuais:

• Use session.thinking.append para informar o progresso em segundo plano, como o de uma consulta ainda em andamento.
• Use session.commentary.append para um resultado verificado que o usuário deve ouvir.
• Use session.instructions.append para orientar o comportamento do assistente com instruções definidas pelo aplicativo.

Os três comandos aceitam content como uma string simples de até 500 tokens e exigem delegation_id. Use o ID original da delegação via cliente para tarefas relacionadas ou null para o contexto geral da sessão. Use client_event_id para associar cada confirmação de recebimento ao comando enviado. Isso confirma que a atualização foi aceita. Use os eventos de transcrição do assistente para observar a fala gerada e o estado do reprodutor para acompanhar a reprodução. Consulte Envie o tipo certo de atualização.

Quando o usuário disser “Na verdade, prefiro sexta-feira”, salve sexta-feira como a solicitação atual, incremente o número da versão e remova qualquer confirmação referente à quinta-feira. Envie a correção ao agente existente. Decida se vai solicitar o cancelamento da consulta de quinta-feira, alterá-la ou deixá-la terminar e descartar o resultado.

Acompanhe o status da consulta antes de informar que ela foi cancelada. Trate essa decisão no backend mesmo que a interrupção do usuário já tenha feito o assistente parar de falar.

As tarefas do backend podem continuar após o fim da sessão de voz. Salve o status delas no aplicativo. Em uma interação por voz posterior, inicie uma nova sessão com o contexto relevante que foi salvo. Consulte Gerenciamento de sessões.

Mantenha a entrada de texto conectada ao agente

Mantenha a entrada de texto digitado conectada ao backend existente. Trate uma correção digitada como uma atualização da mesma tarefa e envie o contexto relevante e verificado à sessão de voz. Consulte Aceite texto digitado e Mantenha as atualizações precisas e úteis.

Adapte as proteções de texto e fala

Um agente de texto ou pipeline em cascata pode validar a resposta completa antes de exibi-la ou reproduzi-la. Com o GPT-Live, a conversa e as tarefas do backend acontecem ao mesmo tempo. Se cada resposta falada precisar passar por uma verificação antes que o usuário a ouça, inclua essa verificação no fluxo de reprodução de áudio controlado pelo aplicativo. Reter apenas um resultado do backend não interrompe toda a fala.

Siga as orientações em Adapte seus mecanismos de proteção para manter suas verificações e levar em conta a continuidade da fala.