For the complete documentation index, see llms.txt. Markdown versions of documentation pages are available by appending .md to the page URL.
Navegação principal
Theme

Sugestões

GPT-Live

Realtime API

Desenvolver aplicações de voz

Conexões

Processamento de áudio

Painel da API
Experimente o ChatGPT

Delegação e ferramentas no GPT-Live

Conecte um agente de backend e envie resultados verificados à conversa em tempo real.

O GPT-Live conduz a conversa por voz e delega o raciocínio e o uso de ferramentas a um backend. O trabalho no backend pode ser executado pelo modelo configurado na Responses ou, com a delegação pelo cliente, por qualquer modelo, agente ou serviço que seu aplicativo opere. Nos dois modos, o aplicativo gerencia as permissões, as confirmações, os registros de negócio e o estado da tarefa.

No guia de prompts, saiba mais sobre como orientar o modelo em tempo real sobre delegação e uso de ferramentas.

Os exemplos de eventos desta página usam connection, uma conexão WebSocket principal ou auxiliar já estabelecida com o Live, conforme os guias de conexão. Na conexão principal, aguarde session.started antes de chamar uma função auxiliar de eventos. Uma conexão auxiliar já vinculada pertence a uma sessão em andamento.

Escolha o modo de delegação

Com a delegação pela Responses, o GPT-Live chama o modelo da Responses que você escolher, fornece o contexto da conversa e traz os resultados do backend para a conversa em tempo real. Com a delegação pelo cliente, seu aplicativo prepara o contexto, executa um agente ou fluxo de trabalho e envia os resultados ao GPT-Live.

Comece com a delegação pela Responses se quiser que o GPT-Live gerencie as solicitações. Escolha a delegação pelo cliente se precisar executar seu próprio fluxo de trabalho ou revisar os resultados antes de enviá-los ao GPT-Live.

Critério Prefira a delegação pela Responses quando… Prefira a delegação pelo cliente quando…
Esforço de implementação Você quer que o GPT-Live prepare as solicitações ao backend, gerencie as conexões e traga os resultados para a conversa. Você quer implementar e operar esses componentes por conta própria.
Revisão dos resultados do backend O backend pode enviar os resultados diretamente ao GPT-Live. Seu aplicativo precisa validar os resultados, ocultar dados, combinar resultados ou descartá-los antes que cheguem ao GPT-Live.
Recursos do backend As configurações e ferramentas da Responses compatíveis com o GPT-Live atendem ao seu fluxo de trabalho. Você precisa de outro backend, de vários modelos ou de recursos da API que a configuração gerenciada não oferece.
Controle do contexto O contexto da conversa fornecido pelo GPT-Live atende às necessidades do aplicativo. Você precisa escolher exatamente quais dados do histórico, da memória e do estado do aplicativo cada solicitação ao backend recebe.
Política de execução Um ciclo de execução com modelo e ferramentas configurados atende à tarefa. Você precisa personalizar o roteamento entre código e modelos, definir alternativas em caso de falha, criar pontos de verificação ou distribuir orçamentos entre as etapas do backend.

Por exemplo, um assistente de viagens pode encaminhar perguntas sobre a situação de um voo ao serviço de uma companhia aérea e pedidos de alteração de itinerário a um agente de planejamento separado. O aplicativo escolhe qual backend chamar e qual resultado verificado enviar ao GPT-Live.

Nos dois modos, o aplicativo acompanha o andamento da tarefa e verifica as permissões e as confirmações exigidas do usuário antes de executar ferramentas personalizadas. O GPT-Live pode continuar falando enquanto o aplicativo revisa um resultado do backend. Se o aplicativo precisar controlar quando o usuário ouve o áudio, adicione controles de reprodução.

A delegação pelo cliente também exige que seu aplicativo mantenha o contexto da conversa. O evento de delegação contém metadados, mas não inclui o texto da tarefa. Use os eventos de transcrição e o estado do aplicativo para preparar a solicitação ao backend.

Ao avaliar seu agente de voz, compare a latência, a taxa de sucesso das tarefas e o custo com sua própria carga de trabalho. Para orientações específicas à arquitetura que você já usa, consulte Migre para o GPT-Live.

Escolha o modo ao criar a sessão. Para mudar de modo, inicie uma nova sessão.

Modo de delegação

Configure a delegação pela Responses

Adicione esta configuração de delegação ao criar sua sessão do Live. Escolha o modelo da Responses independentemente do modelo de voz:

export const session = {
  model: "gpt-live-1",
  delegation: {
    type: "responses",
    responses: {
      model: "gpt-6-luna",
      instructions: "[Your backend prompt]",
    },
  },
};

Comece com gpt-6-luna ou experimente gpt-6-sol para tarefas mais complexas no backend. Compare a qualidade das respostas e a latência nas suas tarefas antes de escolher um modelo para o backend.

Registre as ferramentas compatíveis em delegation.responses.tools. Defina delegation.responses.tool_choice como "auto" para deixar o backend escolher uma ferramenta, "required" para exigir uma chamada de ferramenta ou "none" para desativar essas chamadas. Você também pode selecionar uma função pelo nome.

Defina delegation.responses.parallel_tool_calls como true para permitir várias chamadas de ferramentas em uma resposta ou como false para fazer chamadas sequenciais. Seu aplicativo executa as funções personalizadas e verifica suas dependências e as aprovações necessárias. Essas configurações se aplicam depois que o GPT-Live delega uma tarefa. Use o prompt da conversa em tempo real para orientar o modelo sobre quando delegar.

A configuração da Responses exige um model de backend na criação da sessão. Além das ferramentas abaixo, ela disponibiliza max_output_tokens (no mínimo 16, quando definido), service_tier e as configurações de reasoning e text compatíveis com o modelo de backend selecionado. Consulte Reduza a latência do backend para saber quais configurações você pode ajustar.

Se o modo Fast estiver disponível para seu modelo e projeto, considere usá-lo em chamadas sensíveis à latência. No GPT-Live, selecione esse modo com delegation.responses.service_tier: "priority".

Envie session.update com as alterações em session.delegation.responses para atualizar o modelo de backend, as instruções, as ferramentas, tool_choice ou outras configurações compatíveis durante a conversa. As configurações omitidas mantêm os valores atuais.

Para alternar entre a delegação pela Responses e a delegação pelo cliente, crie uma nova sessão do Live. Alterar delegation para null seleciona o modo cliente. Por isso, enviar essa alteração a uma sessão em andamento no modo Responses gera o erro immutable_field_update.

Essas configurações usam conceitos conhecidos da Responses, mas o Live oferece apenas parte dos recursos da API Responses independente. O Live fornece o contexto da conversa e inicia o trabalho delegado. Configure o backend pela sessão. O comando response.create do Live usa essa configuração e não aceita o corpo de uma solicitação independente da Responses.

Adicione ferramentas hospedadas

Adicione Pesquisa na Web, pesquisa em arquivos, Code Interpreter, Shell hospedado ou geração de imagens a delegation.responses.tools. Consulte os guias nos links para saber como configurar as ferramentas, quais modelos são compatíveis e quais recursos são necessários. A Responses executa essas ferramentas e retorna os resultados automaticamente.

Para executar o shell, use um contêiner hospedado, opcionalmente com Habilidades. Se você acabou de enviar uma Habilidade, aguarde até que a versão referenciada esteja disponível para leitura antes de iniciar a sessão do Live. No shell local, seu aplicativo precisa executar as chamadas. O Live não oferece suporte a domain_secrets do shell.

Adicione MCP e outras ferramentas

A delegação pela Responses também oferece suporte a MCP, pesquisa de ferramentas, chamadas programáticas de ferramentas, funções e ferramentas personalizadas, Uso do computador, shell local e aplicação de patches. Consulte os guias nos links para fazer a configuração. Envie os resultados do aplicativo e as decisões de aprovação pelo fluxo de continuação do Live.

O Live repassa à Responses os valores de authorization e headers que você fornece para o MCP, mas omite esses valores da configuração da sessão que devolve ao aplicativo. Você não precisa reenviá-los ao atualizar outras configurações, como as instruções. Se substituir delegation.responses.tools, inclua novamente as credenciais do MCP.

Trate erros de configuração

O Live valida as configurações da Responses de forma assíncrona após a inicialização e sempre que elas mudam. Os eventos session.started e session.updated não aguardam essa validação. Monitore eventos error com o código responses_validation_failed e consulte a mensagem para identificar a configuração incompatível ou o recurso inacessível. A sessão permanece aberta e as configurações não são revertidas. Corrija-as com session.update.

Por exemplo, um valor numérico de version para uma Habilidade, como 1, gera um erro não fatal responses_validation_failed em session.start ou session.update. A mensagem de erro identifica o campo inválido e o tipo esperado sem aguardar response.create. Associe error.client_event_id ao evento de configuração. Para corrigir o problema na mesma sessão, remova a configuração inválida da ferramenta com session.update. Informe as versões como strings, por exemplo, "1".

A validação não garante que a ferramenta será executada mais tarde. O acesso aos recursos e a disponibilidade das ferramentas podem mudar, portanto continue tratando os erros do backend durante o trabalho delegado. Ao validar a configuração de ferramentas hospedadas, o Live pode inicializar recursos como contêineres.

Oriente a conversa em tempo real pelo aplicativo

A delegação pela Responses gerencia o fluxo de trabalho do backend, mas seu aplicativo ainda pode enviar contexto diretamente ao modelo GPT-Live. Se você monitorar a chamada por um WebSocket auxiliar ou pela conexão principal de eventos, poderá usar session.instructions.append, session.thinking.append ou session.commentary.append com delegation_id: null. Por exemplo, um mecanismo de proteção baseado na transcrição pode acrescentar uma instrução para redirecionar a conversa. Isso orienta o modelo em tempo real, sem alterar o prompt do backend da Responses nem cancelar o trabalho em andamento.

Processe a delegação pela Responses

Quando a Responses executa o trabalho delegado, session.delegation.created contém target: "responses" e um response_id. Os eventos subsequentes da Responses chegam dentro de um envelope response.event:

{
  "type": "response.event",
  "event_id": "event_response_1",
  "delegation_id": "item_9tA2cB6n2V8c4X1z7Q5r9",
  "event": {
    "type": "response.output_text.delta",
    "sequence_number": 4,
    "item_id": "msg_123",
    "output_index": 0,
    "content_index": 0,
    "delta": "The forecast is",
    "logprobs": []
  }
}

Quando o tipo do evento de nível superior for response.event, use envelope.event.type para encaminhá-lo ao tratador adequado. Salve o delegation_id do envelope para associar o evento do backend à delegação correspondente. Seu tratador também pode receber outros eventos aninhados do ciclo de vida da Responses além dos mostrados aqui.

Esses eventos aninhados trazem o andamento das ferramentas hospedadas, citações, arquivos e imagens geradas. Para coletar os resultados, leia os eventos individuais de itens de saída e de imagens parciais. Os registros de estado encaminhados nos eventos do ciclo de vida omitem os arrays de saída. Use as APIs de arquivos ou contêineres correspondentes da Responses para baixar arquivos. Para eventos com imagens ou artefatos grandes, use uma conexão WebSocket principal ou auxiliar, pois o limite de tamanho de mensagem de um canal de dados WebRTC pode ser menor.

A fala em tempo real e o trabalho delegado prosseguem de forma independente. A conclusão de uma resposta do backend, por si só, não indica que o usuário ouviu a resposta. Use a transcrição de saída e o áudio do Live para acompanhar a parte falada da interação.

Envie resultados de ferramentas e decisões de aprovação

Para ferramentas que precisam de dados do aplicativo, colete as chamadas concluídas nos eventos aninhados response.output_item.done. Execute a ação autorizada ou verifique a aprovação e envie o item correspondente com response.item.create:

Item recebido Item de resultado
function_call function_call_output
custom_tool_call custom_tool_call_output
computer_call computer_call_output
shell_call local shell_call_output
apply_patch_call apply_patch_call_output
tool_search_call com execution: "client" tool_search_output com execution: "client" e as ferramentas encontradas em tools
mcp_approval_request mcp_approval_response

Associe os resultados às chamadas usando call_id. Para decisões de aprovação do MCP, defina approval_request_id como o id da solicitação de aprovação e approve como true ou false. A conclusão de mcp_call, por si só, não exige que o cliente envie um resultado. Siga o schema de resultado de cada ferramenta, incluindo os metadados de caller nas chamadas programáticas de funções e as confirmações de segurança exigidas para o uso do computador.

Envie os resultados de todas as chamadas pendentes e, em seguida, envie response.create. Apenas acrescentar um item não retoma a execução no backend. Se faltarem resultados, você receberá tool_outputs_required ou, se faltarem apenas resultados de funções, function_call_outputs_required. O Live rejeita resultados duplicados ou de tipos incompatíveis com a chamada.

Você pode enviar os resultados e solicitar a continuação antes que o backend conclua a resposta atual. Quando aceito, response.create aguarda essa conclusão. Não reenvie o comando. Se o backend emitir outras chamadas depois disso, envie os resultados delas e um novo response.create.

Execute uma função personalizada e envie o resultado

Leia as chamadas de função concluídas nos eventos aninhados response.output_item.done. O item de função concluído contém call_id, name e arguments. O evento que indica a conclusão dos argumentos, sozinho, não basta para identificar a chamada.

Registre o ID da resposta do evento aninhado response.created junto com o delegation_id do envelope. Reúna as chamadas de função da resposta a partir de response.output_item.done e use esse conjunto para determinar quais resultados de ferramentas enviar antes de continuar.

Os eventos de ciclo de vida encaminhados, inclusive response.completed, contêm response.output: [] mesmo quando há chamadas de função que aguardam resultados. Esses eventos também têm um array tools vazio, instructions: null e nenhum campo input. Para obter as chamadas de função, leia os eventos individuais dos itens de saída.

Após executar a operação autorizada, acrescente o resultado como um item da Responses:

export function sendUpdate(connection) {
  connection.send({
    type: "response.item.create",
    event_id: "tool_result_1",
    item: {
      type: "function_call_output",
      call_id: "call_123",
      output: '{"status":"confirmed","order_id":"order_123"}',
    },
  });
}

Em seguida, solicite explicitamente a continuação da resposta:

export function sendUpdate(connection) {
  connection.send({
    type: "response.create",
    event_id: "continue_1",
  });
}

Envie um resultado com response.item.create para cada chamada de função pendente. Depois, envie response.create para continuar a resposta do backend. Não há confirmação de sucesso separada para response.item.create. Continue processando os erros e os eventos aninhados do ciclo de vida da Responses.

Os dois comandos exigem a delegação pela Responses. O comando response.create do Live usa a configuração de backend armazenada na sessão. Use o conteúdo do evento mostrado acima e configure o modelo de backend e os demais parâmetros pela sessão.

Comece com o prompt que você já usa no backend

Use o prompt do seu agente de texto como ponto de partida. Mantenha no backend as instruções da tarefa e as regras de negócio. Adapte as instruções que pressupõem uma conversa por texto ou o controle direto da fala. Explique como lidar com transcrições de voz e retornar resultados úteis. Faça o aplicativo exigir as permissões e as confirmações necessárias.

## Contexto da conversa por voz
Você está ajudando um assistente em uma conversa por voz em tempo real.
As transcrições podem conter erros, frases incompletas e correções posteriores.
Use o contexto mais recente e os registros verificados. Se algum detalhe
necessário ainda estiver pouco claro, peça esclarecimentos em vez de adivinhar.

## Instruções da tarefa
[Your task instructions, business rules, available tools,
and confirmation requirements.]

## Envie o resultado
Informe os fatos relevantes, o estado atual da tarefa e o próximo passo.
Só informe que uma ação foi concluída depois que a ferramenta ou o serviço confirmar o sucesso.
Se houver dúvida sobre o resultado, diga isso e explique o que precisa ser verificado.

Mantenha no backend os dados estruturados volumosos, as saídas extensas das ferramentas e o Markdown destinado à exibição. Envie ao GPT-Live os fatos relevantes e deixe que ele escolha como apresentá-los em voz alta. Quando o resultado da ferramenta é conciso, não é preciso fazer outra chamada ao modelo para adaptá-lo à fala.

Na delegação pelo cliente, envie o resultado diretamente ao GPT-Live. Na delegação pela Responses, envie os resultados de ferramentas ou as decisões de aprovação necessários para dar continuidade ao trabalho no backend. As ferramentas hospedadas prosseguem sem que o aplicativo precise fornecer resultados.

Envie o tipo adequado de atualização

Escolha o evento de acordo com o uso que o GPT-Live deve fazer do conteúdo:

O que você quer enviar Evento
Instruções para a conversa em andamento, como um aviso a ser comunicado ou uma orientação para parar de falar session.instructions.append
Informações para raciocínio interno que o modelo não anuncia ao recebê-las, mas pode usar para responder a perguntas pertinentes do usuário session.thinking.append
Informações que o modelo deve dizer em voz alta, reformulando o texto enviado session.commentary.append

Os três eventos usam uma string simples em content, com limite de 500 tokens por envio. Inclua delegation_id. Use o ID original da delegação pelo cliente para atualizações sobre aquela tarefa ou null para contexto geral da sessão. Um ID não nulo deve identificar uma delegação pelo cliente conhecida. As instruções continuam valendo para a sessão em tempo real. Incluir um ID não as transforma em um prompt separado para o backend.

Para uma saudação inicial, inclua instruções de saudação em uma mensagem developer em session.input ao criar a sessão. Após session.started, envie as mesmas instruções uma única vez por session.commentary.append, com a entrada de áudio ativa, um event_id exclusivo e delegation_id: null. O modelo pode reformular o texto, e a confirmação de recebimento não comprova que ele falou nem que o áudio foi reproduzido. Consulte Cumprimente quem ligou antes que a pessoa fale para ver a sequência completa e saber como controlar a reprodução pelo aplicativo quando precisar usar palavras exatas ou verificar a entrega da saudação.

Acrescentar uma instrução pode interromper a fala ou o comportamento atual do modelo. Use esse recurso quando o aplicativo precisar redirecionar a conversa. Aplique no estado do aplicativo qualquer bloqueio de ferramenta ou ação relacionado à instrução.

Para informar o andamento de uma tarefa gerenciada pelo cliente sem gerar um aviso por voz:

export function sendUpdate(connection) {
  connection.send({
    type: "session.thinking.append",
    event_id: "availability_progress",
    delegation_id: "item_123",
    content: "Checking Thursday availability. No appointment has been booked.",
  });
}

Quando o agendamento estiver confirmado, envie o resultado que o usuário deve ouvir:

export function sendUpdate(connection) {
  connection.send({
    type: "session.commentary.append",
    event_id: "appointment_result",
    delegation_id: "item_123",
    content: "Your appointment is confirmed for Thursday at 2:00 PM",
  });
}

Só envie esse resultado após a conclusão bem-sucedida do agendamento. Para uma instrução válida para toda a sessão, use session.instructions.append com delegation_id: null.

Por exemplo, depois que os mecanismos de proteção do aplicativo bloquearem uma solicitação, você pode redirecionar a conversa:

export function sendUpdate(connection) {
  connection.send({
    type: "session.instructions.append",
    event_id: "guardrail_block_17",
    delegation_id: null,
    content:
      "Stop speaking about that request. Briefly explain that you cannot help with it, then wait for the user.",
  });
}

A instrução não cancela o trabalho no backend. No aplicativo, bloqueie a ação afetada e trate o trabalho que já estiver em andamento.

As confirmações de recebimento correspondentes são session.thinking.appended, session.commentary.appended e session.instructions.appended. Associe o client_event_id delas ao event_id que você enviou. A confirmação aguarda o tempo estimado para incorporar o contexto, sem esperar o fim da fala ou da reprodução. Consulte Quando o contexto chega ao modelo para saber mais sobre os tempos envolvidos e o tratamento de erros.

Envie fatos e resumos breves do andamento da tarefa que o GPT-Live possa usar na conversa. O conteúdo enviado com session.thinking.append pode influenciar respostas faladas posteriores. Mantenha segredos e o raciocínio privado do backend no aplicativo.

Suprima as confirmações automáticas durante a execução das ferramentas

Na delegação pelo cliente, você pode cancelar a confirmação automática pendente enviando uma atualização silenciosa de contexto antes que a confirmação seja gerada.

Defina delegation.acknowledgement_delay_ms ao criar a sessão para dar ao aplicativo tempo de enviar a atualização. Por exemplo, use esta configuração de delegação pelo cliente:

{
  "delegation": {
    "type": "client",
    "acknowledgement_delay_ms": 800
  }
}

Assim que receber session.delegation.created, envie session.thinking.append com content vazio. Use um event_id exclusivo e copie event.delegation.id para delegation_id. Envie o evento antes de aguardar o resultado do backend:

{
  "type": "session.thinking.append",
  "event_id": "event_quiet_progress_1",
  "delegation_id": "item_9tA2bF3h7K9m2P5q8R1s4",
  "content": ""
}

Prossiga com o trabalho no backend. Quando o resultado estiver verificado e pronto para ser dito em voz alta, envie-o por session.commentary.append com o mesmo ID de delegação. Se quiser informar o andamento da tarefa, uma mensagem factual como "Consulta em andamento." na atualização de raciocínio também cancela a confirmação pendente sem pedir ao modelo que anuncie a atualização.

Qualquer atualização de raciocínio ou comentário cancela todas as confirmações automáticas pendentes na sessão, inclusive as de outras delegações. Isso não interrompe o áudio já gerado nem impede que o modelo fale por conta própria. O atraso controla quando a confirmação automática é solicitada, mas o modelo ainda pode falar antes. Consulte a referência da configuração de delegação pelo cliente e do evento de atualização de raciocínio para conferir o contrato do evento.

Associe o evento session.thinking.appended, usando seu client_event_id, ao evento que você enviou. Isso confirma a entrega do contexto, mas não garante silêncio. Teste o áudio resultante com sua carga de trabalho. Use a reprodução controlada pelo aplicativo quando precisar garantir silêncio.

Mantenha as atualizações precisas e úteis

Durante tarefas mais longas, envie uma atualização quando houver uma mudança relevante, como a conclusão de uma etapa, um atraso significativo ou uma pergunta que o usuário precise responder.

Use session.thinking.append para informar o andamento em segundo plano no modo cliente. Use session.commentary.append quando for útil dizer a atualização em voz alta.

Para atualizações por voz, envie session.commentary.append com um conteúdo que corresponda ao estado verificado da tarefa:

Estado Exemplo de conteúdo
Em andamento “Estou verificando os horários disponíveis.”
Concluída “Seu agendamento está confirmado para quinta-feira às 14h.”
Falhou “Esse horário não está mais disponível.”
Cancelamento confirmado “Seu agendamento foi cancelado.”

Quando o usuário alterar uma solicitação, atualize a tarefa ativa no aplicativo. Por exemplo, se a pessoa trocar sexta-feira por quinta-feira, use quinta-feira nas etapas seguintes e ignore os resultados da solicitação anterior para sexta-feira. Gerencie eventuais cancelamentos no backend e confirme que deram certo antes de informar ao usuário que o trabalho foi cancelado. Interromper a conversa por voz deixa o trabalho no backend em execução.

Antes de repetir uma chamada de ferramenta que falhou, verifique se a ação original já ocorreu. Por exemplo, a perda de uma resposta não deve gerar um segundo agendamento. Se o resultado for incerto, informe isso e ofereça um próximo passo útil.

Compartilhe o contexto da interface

Envie ao GPT-Live um resumo conciso da página ou tarefa atual, das seleções relevantes e dos fatos que ajudam a interpretar referências como “esta opção”. Monte o resumo diretamente a partir do estado do aplicativo. Não é preciso fazer outra chamada ao modelo para formatá-lo.

Envie o contexto da interface no início da sessão e quando houver mudanças relevantes de estado. Evite reenviar informações que não mudaram e, se houver várias mudanças em rápida sucessão, reúna-as em um breve resumo do estado mais recente. Indique explicitamente as alterações nas seleções anteriores:

  • Contexto inicial: “O usuário está conferindo os dados de uma reserva de restaurante para duas pessoas em 6 de agosto às 19h. A reserva ainda não foi feita.”
  • Correção: “O horário selecionado agora é 20h. Antes, era 19h.”

Nos dois modos de delegação, use session.thinking.append com delegation_id: null para atualizar o contexto em segundo plano. Mantenha o HTML completo, as árvores do DOM, os grandes volumes de dados JSON e os logs de interação no aplicativo ou no backend. Trate o conteúdo da página como dados de referência, sem interpretá-lo como instruções.

Aceite dados digitados

Envie valores digitados, como números de pedidos, ao backend como dados fornecidos pelo usuário para que ele possa usar o texto exato.

Na delegação pela Responses, coloque uma mensagem do usuário na fila do backend:

export function sendUpdate(connection) {
  connection.send({
    type: "response.item.create",
    event_id: "typed_order_number",
    item: {
      type: "message",
      role: "user",
      content: [
        {
          type: "input_text",
          text: "My order number is A0042.",
        },
      ],
    },
  });
}

Envie response.create quando quiser iniciar ou retomar a execução no backend. Se o backend estiver aguardando resultados de funções, envie primeiro todos os resultados exigidos. Colocar texto na fila, por si só, não cancela o trabalho em andamento.

Adicione imagens e contexto visual

Para ajudar a pessoa que ligou a conversar sobre uma foto ou tela, envie a imagem e o contexto relevante do aplicativo a um backend capaz de processar imagens. O backend interpreta a imagem e retorna o texto relevante para o GPT-Live usar na conversa. O frontend de áudio do Live não aceita imagens diretamente.

Na delegação pela Responses, configure um modelo de backend capaz de processar imagens. Use response.item.create para colocar na fila um item de entrada de imagem compatível com a Responses. Em seguida, envie response.create para iniciar ou retomar o trabalho no backend. Antes de continuar, envie todos os resultados de ferramentas e decisões de aprovação exigidos que ainda estiverem pendentes. Consulte Processe a delegação pela Responses.

Mantenha a entrada de imagens do backend separada de session.input, que fornece o histórico de texto inicial ao frontend do Live. Consulte Imagens e visão para conferir os formatos de imagem compatíveis e as limitações dos modelos.

Reduza a latência do backend

Reduza o intervalo entre a solicitação de trabalho ao backend e a chegada de um resultado útil para a conversa. Meça a latência em cada etapa para identificar os atrasos. Nos mesmos cenários, compare o tempo até uma resposta falada útil e a taxa de sucesso das tarefas. Para orientações sobre a avaliação, consulte o guia do Cookbook sobre avaliação de agentes de voz.

Delegação pela Responses

O Live gerencia conexões WebSocket persistentes com a Responses e prepara antecipadamente as configurações já conhecidas da solicitação. Também pode reutilizar o estado de respostas anteriores quando a conexão ativa e o estado permitirem. Para avaliar o efeito na sua carga de trabalho, meça o tempo de resposta e acompanhe o uso de cache informado.

Ajuste o backend em delegation.responses:

  • model: escolha o modelo responsável pelo raciocínio e pela seleção de ferramentas independentemente do modelo de voz.
  • reasoning.effort: equilibre o tempo de raciocínio e a qualidade do resultado usando valores compatíveis com o modelo.
  • service_tier: use auto, default, flex ou priority, conforme o suporte do modelo e o acesso do projeto. O valor auto segue a configuração do projeto. Avalie o desempenho e o custo do nível de serviço escolhido.

Durante a sessão, atualize as configurações compatíveis com session.update. As ferramentas personalizadas continuam sendo executadas no aplicativo. Por isso, chamadas lentas a serviços, filas e o armazenamento temporário de resultados das ferramentas podem atrasar a resposta mesmo quando o Live gerencia a conexão com a Responses. Envie cada resultado exigido assim que estiver disponível e dê continuidade à resposta do backend.

Reaja aos fragmentos de transcrição

O processamento de fragmentos de transcrição no aplicativo é opcional e funciona nos dois modos de delegação. Os fragmentos de transcrição das falas do usuário e do assistente chegam por WebSocket ou pelo canal de dados WebRTC. Você pode processá-los com a lógica do aplicativo ou com um modelo leve para iniciar o trabalho antes da chegada de um evento de delegação. Também pode usar a própria transcrição para acionar tarefas gerenciadas pelo aplicativo.

Use essa abordagem para:

  • Reduzir a espera. Inicie uma consulta antecipada quando houver informações suficientes. Por exemplo, verifique a disponibilidade enquanto o usuário ainda descreve suas preferências.
  • Aplicar mecanismos de proteção. Examine a transcrição à medida que ela chega para identificar solicitações ou respostas que exigem intervenção. Consulte Aplique mecanismos de proteção à conversa.
  • Adaptar a conversa. Identifique expressões que indiquem confusão ou frustração. Em seguida, ajuste a experiência ou envie uma instrução específica.
  • Atualizar a interface. Destaque controles relevantes, preencha os campos sugeridos ou mostre os resultados à medida que ficarem disponíveis.

Em aplicativos de navegador, use o canal de dados WebRTC para legendas e atualizações locais da interface. Quando o servidor processar as transcrições para aplicar mecanismos de proteção, fazer verificações com um modelo leve ou antecipar chamadas de ferramentas, use um WebSocket auxiliar para receber eventos e orientar diretamente a mesma sessão do GPT-Live.

Processe o texto acumulado quando chegarem novas informações relevantes. Um fragmento pode estar incompleto, e a continuação da fala pode alterar o pedido. Descarte os resultados desatualizados, coordene a execução com o trabalho delegado posteriormente para evitar ações duplicadas e faça as verificações habituais de permissão e confirmação antes de executar ações com consequências importantes.

Envie as conclusões ou instruções ao GPT-Live usando o evento correspondente ao tipo de atualização. Para trabalho iniciado fora de uma delegação pelo cliente, use delegation_id: null. Seu aplicativo aplica as alterações à interface e gerencia a execução e o cancelamento das ferramentas.

Otimizações comuns aos dois modos

As mesmas melhorias no backend beneficiam os dois modos de delegação:

  • Escolha o modelo e o esforço de raciocínio de acordo com a tarefa. Compare configurações que atendam aos seus requisitos de precisão. Use um esforço de raciocínio menor quando ele permitir concluir a tarefa de forma confiável.
  • Mantenha as respostas concisas. Envie os fatos e o estado da tarefa de que o GPT-Live precisa para continuar a conversa. Evite explicações longas e chamadas extras ao modelo apenas para adaptar os resultados à fala.
  • Reduza os atrasos das ferramentas e evite chamadas desnecessárias. Inicie o trabalho autorizado assim que os dados de entrada estiverem prontos, reutilize resultados enquanto forem válidos e evite repetir consultas concluídas.
  • Execute tarefas independentes em paralelo. Consultas independentes podem ser executadas simultaneamente. Respeite as dependências e as confirmações necessárias para cada ação. O parâmetro parallel_tool_calls permite que um modelo solicite várias chamadas. Seu aplicativo continua responsável por agendar e executar as funções personalizadas.

Consulte Otimização da latência para orientações gerais sobre a Responses e Cache de prompts para saber como reutilizar dados de entrada estáveis.

Verifique a interação completa

Verifique se o backend concluiu a ação pretendida e se o cliente reproduziu a resposta falada esperada. Por exemplo, após uma reserva bem-sucedida, confira tanto o registro da reserva quanto o áudio reproduzido. O backend pode concluir o trabalho mesmo que a resposta falada seja interrompida, portanto teste os dois resultados separadamente.

Atribua um ID de operação a cada ação do aplicativo e registre uma revisão da tarefa a cada alteração da solicitação, junto com o ID de delegação do GPT-Live. Use esses registros para identificar o trabalho já concluído após reconexões ou novas tentativas e descartar resultados de solicitações desatualizadas.

Use Avaliação de agentes de voz para criar testes que possam ser repetidos. Se você já usa um ciclo de chamadas de ferramentas no Realtime ou um backend encadeado, siga o guia Migre para o GPT-Live.