Um Novo SO? Apps no ChatGPT & Apps SDK (Baseado em MCP): Desbloqueando uma Nova Plataforma

Blog image

Autor: Boxu Li na Macaron

Introdução:

Apps no ChatGPT agora permitem que desenvolvedores de terceiros construam miniaplicativos interativos que vivem dentro da interface de chat. Em vez de enviar usuários para sites ou aplicativos móveis, esses aplicativos funcionam dentro da conversa e utilizam o raciocínio do modelo para impulsionar ações. Parceiros iniciais como Canva, Coursera, Expedia e Zillow demonstraram como os usuários podem pedir uma playlist, desenhar um cartaz ou buscar imóveis sem sair do ChatGPT[1]. O novo Apps SDK é construído sobre o Model Context Protocol (MCP), um padrão aberto que permite que modelos interajam com ferramentas externas e interfaces de usuário[2]. Este blog mergulha profundamente na arquitetura de aplicativos baseados em MCP, explica as capacidades do SDK, guia através da construção de um aplicativo passo a passo, explora como os usuários descobrem e usam aplicativos, e discute considerações de privacidade e segurança. Ao longo do texto, citamos documentação oficial e jornalismo respeitável para fundamentar a análise em fontes credíveis.

Entendendo o Model Context Protocol (MCP)

Por Que Padrões Abertos Importam

O Protocolo de Contexto de Modelo é a base do SDK de Apps. De acordo com a documentação do desenvolvedor, toda integração do SDK de Apps usa um servidor MCP para expor ferramentas, lidar com autenticação e empacotar tanto dados estruturados quanto HTML que são renderizados no ChatGPT[2]. MCP é um padrão aberto—qualquer um pode implementar um servidor em qualquer linguagem e conectar um modelo como o GPT‑4 ou Codex. A natureza open-source significa que não há bloqueio de fornecedor; teoricamente, o mesmo aplicativo pode rodar em qualquer plataforma de IA que implemente o protocolo. Essa abertura incentiva contribuições da comunidade e promove um ecossistema análogo à web inicial, onde padrões como HTTP permitiram sites interoperáveis.

Servidores, Ferramentas e Recursos

Um servidor MCP expõe uma ou mais ferramentas. Uma ferramenta define uma ação que o modelo pode chamar, como “criar um quadro kanban”, “procurar casas” ou “gerar uma playlist”. Cada ferramenta é descrita por um nome de máquina, um título amigável e um esquema JSON que informa ao modelo quais argumentos aceita. Quando o ChatGPT decide que a ferramenta deve ser invocada, ele envia uma chamada estruturada para o servidor. O servidor executa a lógica—seja consultando uma API, realizando um cálculo ou interagindo com um banco de dados—e então retorna uma resposta da ferramenta. Esta resposta inclui três campos:

structuredContent – dados visíveis para o modelo que descrevem o estado atual. Por exemplo, um quadro kanban pode incluir uma matriz de colunas e tarefas[3].
content – texto opcional que o assistente fala de volta para o usuário. Isso pode resumir o resultado ou instruir o usuário.
_meta – metadados ocultos não visíveis para o modelo. Desenvolvedores usam isso para armazenar IDs ou listas usadas em componentes da interface do usuário. Por exemplo, o exemplo do quadro usa um mapa tasksById em _meta para manter os detalhes das tarefas sem expô-los ao modelo[4].

As ferramentas também podem se referir a recursos, como templates HTML ou imagens, referenciando um URL ui://. O servidor registra esses recursos durante a inicialização. A documentação adverte que, como os recursos são armazenados em cache pela infraestrutura da OpenAI, os desenvolvedores devem versioná-los incluindo um hash de compilação no nome do arquivo[5]. Caso contrário, os usuários podem ver uma interface desatualizada após implantações.

Conteúdo Estruturado vs. Metadados

A distinção entre structuredContent e _meta é fundamental. De acordo com a documentação, structuredContent é visível para o modelo e é usado para hidratar o componente UI; _meta está oculto do modelo e pode conter dados extras para a UI, como listas para menus suspensos[3]. Ao separar dados visíveis e ocultos, os desenvolvedores podem proteger informações sensíveis do modelo enquanto ainda renderizam interfaces ricas. Este design também incentiva o compartilhamento mínimo de dados; somente o que é necessário para realizar a tarefa é exposto, alinhando-se aos princípios de privacidade.

Autenticação e Sessões

Quando um usuário chama um app pela primeira vez, o servidor pode precisar autenticá-lo. O SDK de Apps suporta fluxos OAuth 2.1; os desenvolvedores especificam escopos e redirecionam os usuários para o provedor de identidade. Uma vez que o usuário concede consentimento, o app obtém um token e pode acessar os dados do usuário. A função do servidor é gerenciar o estado da sessão, muitas vezes armazenando tokens em um banco de dados associado à conta ChatGPT do usuário. Isso garante que chamadas subsequentes à ferramenta possam reutilizar a sessão sem pedir novamente ao usuário.

Princípios de Segurança

A OpenAI enfatiza privilégio mínimo, consentimento explícito do usuário e defesa em profundidade[6]. Os aplicativos devem solicitar apenas as permissões mínimas necessárias, e os usuários devem autorizar explicitamente o compartilhamento de dados; o próprio modelo nunca deve adivinhar credenciais. A retenção de dados é limitada: o conteúdo estruturado permanece apenas enquanto o prompt do usuário estiver ativo, e os registros são redigidos antes de serem compartilhados com os desenvolvedores[6]. O acesso à rede para os componentes do aplicativo é restrito por uma política de segurança de conteúdo; iframes não podem acessar APIs de navegador arbitrárias, e todas as solicitações HTTP devem se originar do servidor em vez do cliente[7]. Isso previne scripts de sites cruzados e exfiltração de tokens.

O SDK de Apps: Construindo Aplicações Reais no ChatGPT

Blog image

A Experiência do Desenvolvedor

O SDK de Apps envolve o MCP em bibliotecas cliente idiomáticas (atualmente Python e TypeScript) e ferramentas de scaffolding. Quando você cria um app, define as ferramentas, registra modelos de UI e implementa a lógica do servidor. O servidor pode rodar na sua própria infraestrutura e usar qualquer framework (FastAPI, Express, etc.), mas deve implementar os endpoints do MCP. A OpenAI fornece servidores de desenvolvimento e um Inspetor MCP para testar chamadas localmente.

Os desenvolvedores projetam tanto a lógica quanto a interface do usuário. As interfaces são geralmente escritas em React e compiladas em recursos estáticos. Elas são servidas dentro de um iframe isolado no ChatGPT. Dentro deste iframe, os desenvolvedores podem acessar um objeto global window.openai para interagir com o host. De acordo com o guia Construa uma UX personalizada, esta API fornece:

Globais – displayMode, maxHeight, theme e locale informam o componente sobre layout e estilo[8].
Payloads de Ferramentas – toolInput, toolOutput e widgetState permitem ler os argumentos, resultados e estado persistente entre renderizações[8].
Ações – setWidgetState() salva o estado que persiste entre mensagens; callTool() aciona uma ação no servidor; sendFollowupTurn() envia um prompt de acompanhamento para o modelo; requestDisplayMode() pede para ir para tela cheia ou picture‑in‑picture[8].
Eventos – o componente pode se inscrever em openai:set_globals quando o host atualiza o layout ou tema, e openai:tool_response quando uma chamada de ferramenta é resolvida[8].

Essas APIs permitem que os desenvolvedores construam componentes interativos ricos que permanecem sincronizados com o raciocínio do modelo. Por exemplo, se um usuário arrasta uma tarefa para uma nova coluna em um quadro kanban, o componente pode enviar um callTool para atualizar o servidor, persistir o novo estado e, em seguida, retornar um novo structuredContent. Enquanto isso, o modelo vê apenas o estado do quadro em alto nível; a interface de usuário lida com detalhes como arrastar e soltar.

Registrando Ferramentas e Modelos

In the server code you register a tool and its template. For instance, in a TypeScript server you might write:

import { Tool, StructuredToolResponse } from "@openai/apps";

// Register UI template
server.registerResource("ui://kanban-board/abc123", buildHtml());

// Define tool schema
const createBoard: Tool = {
  name: "createKanbanBoard",
  description: "Create a new kanban board with given tasks and columns",
  inputSchema: z.object({
    title: z.string(),
    columns: z.array(z.object({ name: z.string() })),
    tasks: z.array(z.object({ name: z.string(), columnIndex: z.number() }))
  }),
  async execute(input, ctx): Promise<StructuredToolResponse> {
    // compute board state
    const columns = input.columns.map((col, i) => ({
      id: i,
      title: col.name,
      taskIds: input.tasks.filter(t => t.columnIndex === i).map((_t, idx) => idx)
    }));
    const tasksById = input.tasks.map((task, id) => ({ id, name: task.name }));
    return {
      content: `Created board '${input.title}'`,
      structuredContent: { title: input.title, columns },
      _meta: { tasksById, uiTemplate: "ui://kanban-board/abc123" }
    };
  }
};

The _meta field includes tasksById for hidden metadata and uiTemplate referencing the registered HTML. When ChatGPT receives this response, it will render the template with the structured content. The window.openai.toolOutput object in the component can then read the board data and display it.

Versionamento e Cache

Como recursos como templates de UI são armazenados em cache nos servidores da OpenAI, os desenvolvedores devem incluir um hash único ou versão no identificador ui://. A documentação alerta que, se você implantar uma nova versão sem atualizar o caminho, os usuários podem continuar vendo a UI antiga devido ao cache[5]. Uma prática recomendada é incorporar o SHA do commit ou o ID da build na URL. Isso garante que cada implantação resulte em um recurso novo.

Persistindo Estado e Acompanhamentos

Componentes muitas vezes precisam persistir estado. Por exemplo, um aplicativo de playlist pode permitir que os usuários favoritem músicas; essas favoritas devem permanecer mesmo quando o usuário fizer outra pergunta. O método setWidgetState() armazena dados fora do structuredContent e persiste entre as interações[8]. O modelo não vê esse estado, garantindo a privacidade.

Às vezes, um aplicativo precisa fazer uma pergunta de esclarecimento ao usuário. O método sendFollowupTurn() permite que o componente envie um novo prompt de volta para o ChatGPT, que aparecerá na transcrição como se o modelo tivesse feito a pergunta[8]. Isso é útil para fluxos de trabalho em várias etapas: por exemplo, um aplicativo de reserva de viagens pode perguntar “Quantas noites você vai ficar?” depois que o usuário selecionar um hotel.

Building Your First App: Step‑By‑Step Guide

In this section we will build a simple Task Tracker app that demonstrates the core concepts of the Apps SDK. The app will let a user create tasks and organise them into categories. We choose this example because it is generic, easy to extend and showcases structured content, metadata, custom UI and tool calls.

Set up the MCP Server

First install the TypeScript SDK and scaffolding tool:

npm install -g @openai/apps-generator
apps init task-tracker
cd task-tracker
npm install

This command scaffolds a project with a server, a React frontend and build scripts. The server uses Express and the @openai/apps library. Run npm run dev to start the development server; the project includes an MCP Inspector that opens in your browser and simulates ChatGPT calling your app.

Define the Tool

Open src/server.ts and define a tool called createTasks. The tool accepts an array of tasks and returns structured content grouping them by category. It also provides a summary in the content field.

import { Tool, StructuredToolResponse } from "@openai/apps";



export const createTasks: Tool = {
  name: "createTasks",
  description: "Create a list of tasks grouped by category",
  inputSchema: z.object({ tasks: z.array(z.object({ name: z.string(), category: z.string() })) }),
  async execute({ tasks }): Promise<StructuredToolResponse> {
    const categories = Array.from(new Set(tasks.map(t => t.category)));
    const grouped = categories.map(category => ({
      name: category,
      taskIds: tasks.filter(t => t.category === category).map((_, i) => i)
    }));
    const tasksById = tasks.map((task, id) => ({ id, name: task.name, category: task.category }));
    return {
      content: `Created ${tasks.length} tasks in ${categories.length} categories`,
      structuredContent: { categories: grouped },
      _meta: { tasksById, uiTemplate: "ui://task-tracker/1.0.0" }
    };
  }
};

server.registerResource("ui://task-tracker/1.0.0", fs.readFileSync(path.join(__dirname, "../dist/index.html"), "utf8"));
server.registerTool(createTasks);

Build the Custom UI

Next open src/frontend/App.tsx. This React component will read the structuredContent and display categories and tasks. It will also allow users to mark tasks as complete and persist that state using setWidgetState.

import { useEffect, useState } from "react";

declare global {
  interface Window {
    openai: any;
  }
}



export default function App() {
  const [complete, setComplete] = useState<{ [id: string]: boolean }>(() => window.openai.widgetState?.complete || {});
  const output = window.openai.toolOutput;
  const tasksById = output?._meta?.tasksById || [];
  const categories = output?.structuredContent?.categories || [];

  // persist completion state
  useEffect(() => {
    window.openai.setWidgetState({ complete });
  }, [complete]);

  return (
    <div className="task-tracker">
      {categories.map((cat: any, ci: number) => (
        <div key={ci} className="category">
          <h3>{cat.name}</h3>
          <ul>
            {cat.taskIds.map((tid: number) => (
              <li key={tid}>
                <label>
                  <input type="checkbox" checked={complete[tid]} onChange={() => setComplete(prev => ({ ...prev, [tid]: !prev[tid] }))} />
                  {tasksById[tid].name}
                </label>
              </li>
            ))}
          </ul>
        </div>
      ))}
    </div>
  );
}

This component uses window.openai.toolOutput to access the structuredContent and _meta fields. It stores completion state in widgetState so that checking a box persists even when the user continues the conversation. On subsequent tool calls, the component can fetch new tasks or update existing ones. This demonstrates how to combine model reasoning with client‑side interactions.

Testing and Iterating

Run npm run dev again and open the MCP Inspector. In the prompt area, type:

@task‑tracker create a list of tasks: buy milk in shopping, finish report in work, call mom in personal

The inspector will show the structured content and render the task list UI. You can check tasks off; the state persists across turns. You can then ask ChatGPT: “Remind me of my tasks later.” Because the model retains context, it can call the tool again, display the UI and summarise your progress.

How Users Discover and Use Apps

Blog image

Named Mention and In‑Conversation Discovery

ChatGPT surfaces apps when it believes they can assist the user. There are two primary discovery modes. Named mention occurs when the user explicitly mentions the app name at the beginning of a prompt; in this case, the app will be surfaced automatically[9]. For instance, “@Spotify create a workout playlist” immediately invokes the Spotify integration. The user must place the app name at the start; otherwise the assistant may treat it as part of the conversation.

In‑conversation discovery happens when the model infers that an app could help based on context. The documentation explains that the model evaluates the conversation context, prior tool results and the user’s linked apps to determine which app might be relevant[9]. For example, if you are discussing travel plans, ChatGPT might suggest the Expedia app to book flights. The algorithm uses metadata like tool descriptions and keywords to match the conversation with potential actions[10]. Developers can improve discoverability by writing action‑oriented descriptions and clear UI component names.

Directory and Launcher

OpenAI plans to release an app directory where users can browse and discover new apps[10]. Each listing will include the app name, description, supported prompts and any onboarding instructions. Users can also access the launcher via the “+” button in chat; this shows a menu of available apps based on context. These entry points will help less technical users find and enable apps without memorising names.

Onboarding and Consent

Na primeira vez que um usuário ativa um aplicativo, o ChatGPT inicia um fluxo de integração. O modelo pede ao usuário para conectar sua conta (se necessário) e explica quais dados o aplicativo precisa. As diretrizes para desenvolvedores enfatizam que os aplicativos devem respeitar a privacidade dos usuários, comportar-se de forma previsível e ter políticas claras[11]. Os usuários devem conceder ou negar permissão explicitamente; não há acesso silencioso aos dados. Uma vez conectado, o aplicativo pode permanecer vinculado para interações subsequentes, mas os usuários sempre têm a capacidade de desconectar e revogar permissões.

Privacidade, Segurança e Design Responsável

Princípios de Aplicativos Confiáveis

As Diretrizes para Desenvolvedores de Apps do OpenAI definem vários princípios para garantir que o ecossistema permaneça seguro e confiável. Os aplicativos devem fornecer um serviço legítimo, ter uma política de privacidade clara e práticas de retenção de dados, e cumprir as políticas de uso[11]. Eles devem minimizar a coleta de dados, evitar o armazenamento de informações pessoais sensíveis e não compartilhar dados do usuário sem consentimento[12]. Os aplicativos devem se comportar de forma previsível; não podem manipular o modelo para produzir conteúdo prejudicial ou enganoso.

Limites e Minimização de Dados

As diretrizes enfatizam que os aplicativos devem coletar apenas os dados essenciais para seu funcionamento e não devem solicitar ou armazenar dados sensíveis, como registros de saúde ou documentos de identidade emitidos pelo governo[12]. O conteúdo estruturado enviado ao modelo não deve conter segredos; metadados ocultos não devem armazenar tokens de usuário ou detalhes privados. Os desenvolvedores devem implementar criptografia forte e armazenamento seguro para quaisquer tokens obtidos durante o OAuth. O servidor deve manter limites estritos entre sessões de usuários; dados de um usuário nunca devem vazar para o contexto de outro.

Medidas de Segurança no SDK

O Guia de Segurança e Privacidade descreve os mecanismos de defesa incorporados à plataforma. Destaca o princípio do menor privilégio e o consentimento explícito do usuário como princípios centrais[6]. A retenção de dados é limitada; os logs acessíveis aos desenvolvedores são editados para remover informações pessoalmente identificáveis, e o conteúdo estruturado é retido apenas enquanto o prompt exigir[6]. O acesso à rede a partir do iframe é restrito pela política de segurança de conteúdo; buscas externas devem passar pelo servidor, prevenindo solicitações cross-origin não autorizadas[7]. A autenticação utiliza fluxos padrão da indústria OAuth com tokens de curta duração. Os desenvolvedores são obrigados a implementar revisões de segurança, canais de relatórios de bugs e monitoramento de incidentes para manter a prontidão operacional[7].

Justiça e Adequação

Os aplicativos devem ser adequados para um público amplo. As diretrizes proíbem aplicativos que entregam conteúdo de longa duração, automação complexa ou anúncios[13]. Por exemplo, um aplicativo não deve tentar entregar um vídeo de 30 minutos ou replicar uma rede social inteira dentro do ChatGPT. A plataforma incentiva interações sucintas que complementam o fluxo de conversação. Violações podem levar à rejeição ou remoção.

Oportunidades e Considerações

Um Novo Canal de Distribuição para Desenvolvedores

Ao abrir o ChatGPT para aplicativos de terceiros, a OpenAI se posiciona como uma “camada de intenção” entre usuários e serviços. Os desenvolvedores agora podem alcançar milhões de usuários através da interface de chat sem construir aplicativos web ou móveis separados. Os aplicativos têm o potencial de reduzir a fricção: em vez de baixar um aplicativo ou visitar um site, os usuários apenas mencionam o serviço na conversa. Isso poderia democratizar o acesso a ferramentas e nivelar o campo de jogo para pequenos desenvolvedores.

Parcerias iniciais mostram as possibilidades: os usuários podem assistir a palestras da Coursera enquanto fazem perguntas ao ChatGPT; criar pôsteres no Canva; explorar opções de viagem no Expedia ou listagens imobiliárias no Zillow; gerar playlists no Spotify; ou diagramar ideias com o Figma[14][13]. Como os aplicativos funcionam dentro do chat, o modelo pode resumir, analisar e gerar recomendações, transformando conteúdo estático em lições interativas. Os aplicativos também oferecem múltiplos modos de exibição—cartões em linha, tela cheia ou picture-in-picture—proporcionando flexibilidade para diferentes tarefas[15].

Transformando as Expectativas dos Usuários

A capacidade de usar aplicativos sem mudar de contexto pode redefinir a forma como as pessoas interagem com serviços. O ChatGPT se torna não apenas um chatbot, mas um sistema operacional universal para intenções. Como observou Casey Newton, isso nos move de lançar aplicativos discretos para simplesmente dizer o que queremos[16]. Alguns analistas comparam essa mudança ao lançamento da App Store ou do navegador: uma única plataforma que agrega funcionalidade e competição.

No entanto, essa transformação levanta questões sobre controle e poder. Se o ChatGPT determinar quais aplicativos serão exibidos, pode se tornar um guardião. Newton alerta que um “grafo de IA” baseado nas preferências dos usuários pode criar riscos de privacidade mais sérios do que os das redes sociais[16]. Incentivos econômicos podem levar a uma colocação ou classificação paga de aplicativos. Os desenvolvedores podem sentir-se pressionados a projetar para o ChatGPT em vez de manter seu relacionamento com os usuários. É crucial que a plataforma permaneça transparente e justa para manter a confiança.

Implicações Regulamentares e Éticas

Como os aplicativos podem acessar dados pessoais — localização, contatos, métodos de pagamento — os reguladores podem examinar como os dados fluem pelo ChatGPT. Os desenvolvedores devem cumprir as leis de privacidade, como o GDPR, mesmo que a plataforma ainda não esteja disponível na União Europeia[17]. A OpenAI prometeu controles de privacidade mais granulares e opções de monetização, incluindo um protocolo de comércio agente que permitirá checkout instantâneo dentro do chat[18]. O sucesso desse ecossistema dependerá de segurança robusta, consentimento claro do usuário e modelos econômicos justos.

Direções Futuras e Pesquisa

O Apps SDK ainda está em pré-visualização, e muitos recursos precisam ser desenvolvidos. O roteiro do desenvolvedor inclui:

Fluxo de submissão e revisão – Atualmente, os desenvolvedores podem criar aplicativos, mas não podem listá-los publicamente. Um processo formal de revisão garantirá conformidade com diretrizes e confiança.
Compartilhamento de receita e monetização – A OpenAI sugeriu um protocolo de comércio agentivo que poderia permitir que os usuários comprassem produtos diretamente no chat[18]. Isso gera oportunidades para e-commerce, mas também levanta questões sobre taxas, classificações e concorrência.
Ferramentas para desenvolvedores – Mais linguagens e frameworks, ferramentas de depuração aprimoradas e pipelines de implantação mais fáceis reduzirão a barreira de entrada. A natureza de padrão aberto do MCP pode levar a implementações impulsionadas pela comunidade e provedores de hospedagem.
Interoperabilidade – Como o MCP é aberto, outras plataformas ou modelos podem adotá-lo. Isso poderia possibilitar um ecossistema de aplicativos cross-modelo, onde desenvolvedores escrevem uma vez e executam em qualquer lugar. Pesquisas sobre padronização de protocolos de agentes e compartilhamento de contexto serão importantes.
Pesquisa de segurança – Avaliar como prevenir injeção de prompts, código malicioso ou uso indevido de dados do usuário continua sendo uma área importante de pesquisa. Artigos sobre ataques adversariais contra aplicações integradas a LLM informarão melhores práticas e diretrizes.

Conclusão: Um novo sistema operacional em construção

A introdução de Apps no ChatGPT e do SDK de Apps baseado em MCP marca uma mudança significativa em como interagimos com software. Ao trazer aplicativos de terceiros diretamente para a interface de chat, a OpenAI criou uma nova plataforma que mistura linguagem natural, raciocínio e interfaces interativas. O Protocolo de Contexto do Modelo fornece uma maneira aberta e padronizada para modelos chamarem ferramentas e renderizarem componentes; o SDK de Apps simplifica o desenvolvimento ao gerenciar a comunicação com o servidor, integração de UI e gerenciamento de estado. Exemplos passo a passo como o Task Tracker demonstram como é fácil construir um aplicativo útil enquanto mantém limites rigorosos de dados e privacidade.

No entanto, essa inovação vem com responsabilidades. Os desenvolvedores devem seguir diretrizes que priorizem a privacidade, segurança e justiça dos usuários[11][12]. Mecanismos de segurança como o princípio do menor privilégio e o consentimento explícito protegem os usuários[6]. Ao mesmo tempo, observadores da indústria alertam que a plataforma pode criar novas formas de controle e riscos à privacidade[16]. À medida que o ecossistema amadurece, a transparência, os padrões abertos e o envolvimento da comunidade determinarão se a plataforma de aplicativos do ChatGPT se tornará uma camada transformadora e confiável para tarefas do dia a dia.

[1] Últimas Notícias da Corrida Armamentista de IA: ChatGPT Agora Permite que Usuários Conectem-se com Spotify e Zillow em Conversas

https://www.forbes.com/sites/antoniopequenoiv/2025/10/06/openais-chatgpt-now-connects-with-third-party-apps-like-spotify-and-zillow-heres-the-latest-in-the-ai-arms-race/

[2] [3] [4] [5] Configure seu servidor

https://developers.openai.com/apps-sdk/build/mcp-server

[6] [7] Segurança e Privacidade

https://developers.openai.com/apps-sdk/guides/security-privacy

[8] Crie uma UX personalizada

https://developers.openai.com/apps-sdk/build/custom-ux

[9] [10] Interação do Usuário

https://developers.openai.com/apps-sdk/concepts/user-interaction

[11] [12] Diretrizes para desenvolvedores de aplicativos

https://developers.openai.com/apps-sdk/app-developer-guidelines/