@orbe-agro/client-core 5.6.262 → 5.6.264

package/lib/@ecme/views/concepts/ai/Chat/hooks/useChatConversations.tsx

@@ -0,0 +1,128 @@
+import useSWR from 'swr'
+import Notification from '@/components/ui/Notification'
+import toast from '@/components/ui/toast'
+import {
+    apiDeleteConversation,
+    apiGetConversations,
+    apiRenameConversation,
+} from '@/services/AiService'
+import { useSessionUser } from '@/store/authStore'
+import { usGenerativeChatStore } from '../store/generativeChatStore'
+import { resumoParaHistorico } from '../utils'
+import type { ChatHistories, GetConversationsResponse } from '../types'
+
+const avisarFalha = (mensagem: string) => {
+    toast.push(
+        <Notification type="danger" duration={3000}>
+            {mensagem}
+        </Notification>,
+        { placement: 'top-center' },
+    )
+}
+
+/**
+ * A lista de conversas do usuário, persistida no backend, e as ações sobre ela.
+ *
+ * Renomear e excluir são otimistas: a tela muda na hora e volta ao estado
+ * anterior se o backend recusar.
+ */
+const useChatConversations = () => {
+    const {
+        setChatHistory,
+        setChatHistoryName,
+        setSelectedConversation,
+    } = usGenerativeChatStore()
+
+    const userId = useSessionUser((state) => state.user.userId)
+    const signedIn = useSessionUser((state) => state.session.signedIn)
+
+    // O usuário faz parte da chave: cada um tem o próprio cache, e o de quem
+    // saiu nunca é servido a quem entrou. Sem sessão, não busca nada.
+    //
+    // Sem `revalidateIfStale: false` de propósito: cada vez que a lista monta,
+    // ela confere o backend. Com ele, o SWR servia o cache antigo, não chamava
+    // o `onSuccess`, e a lista só aparecia depois de um F5.
+    useSWR(
+        signedIn && userId ? ['/ai/chat/conversations', userId] : null,
+        // O dono viaja junto com a resposta para o `onSuccess` conferir.
+        async ([, dono]: [string, string]) => ({
+            dono,
+            resumos: await apiGetConversations<GetConversationsResponse>(),
+        }),
+        {
+            revalidateOnFocus: false,
+            revalidateOnReconnect: false,
+            onSuccess: ({ dono, resumos }) => {
+                // Resposta atrasada de quem já saiu: descarta, senão a lista
+                // de um usuário cairia na tela do outro.
+                if (dono !== useSessionUser.getState().user.userId) {
+                    return
+                }
+                // Lido na hora, e não da closure: a resposta pode chegar
+                // depois de o usuário já ter começado uma conversa.
+                const atual = usGenerativeChatStore.getState().chatHistory
+                setChatHistory(mesclar(atual, resumos))
+            },
+        },
+    )
+
+    const remover = async (id: string) => {
+        const { chatHistory, selectedConversation } =
+            usGenerativeChatStore.getState()
+
+        setChatHistory(chatHistory.filter((item) => item.id !== id))
+        if (selectedConversation === id) {
+            setSelectedConversation('')
+        }
+
+        try {
+            await apiDeleteConversation(id)
+        } catch {
+            setChatHistory(chatHistory)
+            avisarFalha('Não foi possível excluir a conversa.')
+        }
+    }
+
+    const renomear = async (id: string, title: string) => {
+        const anterior = usGenerativeChatStore
+            .getState()
+            .chatHistory.find((item) => item.id === id)?.title
+
+        setChatHistoryName({ id, title })
+
+        try {
+            await apiRenameConversation(id, title)
+        } catch {
+            if (anterior !== undefined) {
+                setChatHistoryName({ id, title: anterior })
+            }
+            avisarFalha('Não foi possível renomear a conversa.')
+        }
+    }
+
+    return { remover, renomear }
+}
+
+/**
+ * Junta a lista do backend com o que já está na tela.
+ *
+ * - Conversa que já existe no store fica como está: pode ter mensagens
+ *   carregadas ou um stream em andamento.
+ * - Conversa criada nesta sessão e que o backend ainda não conhece não pode
+ *   sumir: ela aparece primeiro, como ao ser criada.
+ */
+function mesclar(
+    atual: ChatHistories,
+    resumos: GetConversationsResponse,
+): ChatHistories {
+    const noStore = new Map(atual.map((chat) => [chat.id, chat]))
+    const doBackend = new Set(resumos.map((resumo) => resumo.id))
+
+    const soNaTela = atual.filter((chat) => !doBackend.has(chat.id))
+    const daLista = resumos.map(
+        (resumo) => noStore.get(resumo.id) ?? resumoParaHistorico(resumo),
+    )
+    return [...soNaTela, ...daLista]
+}
+
+export default useChatConversations

package/lib/@ecme/views/concepts/ai/Chat/hooks/useChatSend.ts

@@ -1,15 +1,23 @@
 import { usGenerativeChatStore } from '../store/generativeChatStore'
-import { apiPostChat } from '@/services/AiService'
+import { resumeChat, streamChat } from '@/services/AiService'
+import { useAuth } from '@/auth'
 import dayjs from 'dayjs'
 import uniqueId from 'lodash/uniqueId'
-import type { PostAiChatResponse } from '../types'
+import { novoIdDeConversa } from '../utils'
+import type { ChatEvent, Conversation, ToolCall } from '../types'
+
+/** Resposta genérica exibida no chat quando a comunicação com a IA falha. */
+const AI_ERROR_MESSAGE =
+    'Desculpe, estou com um pequeno problema de comunicação e não consigo te atender no momento. Tente novamente em instantes.'
 
 const useChatSend = () => {
+    const { user } = useAuth()
     const {
         selectedConversation,
         setSelectedConversation,
         pushChatHistory,
         pushConversation,
+        updateConversation,
         setIsTyping,
     } = usGenerativeChatStore()
 
@@ -17,9 +25,9 @@ const useChatSend = () => {
         pushConversation(id, {
             id: uniqueId('ai-conversation-'),
             sender: {
-                id: '1',
-                name: 'Angelina Gotelli',
-                avatarImageUrl: '/img/avatars/thumb-1.jpg',
+                id: user.userId ?? 'me',
+                name: user.userName ?? 'Você',
+                avatarImageUrl: user.avatar ?? undefined,
             },
             content: prompt,
             timestamp: dayjs().toDate(),
@@ -28,62 +36,259 @@ const useChatSend = () => {
         })
     }
 
-    const sendMessage = async (
-        id: string,
-        prompt: string,
-        attachments?: File[],
+    /**
+     * Cria a mensagem da IA vazia e devolve o id, para o streaming preenchê-la.
+     *
+     * `fresh: false` é obrigatório: `fresh` liga a animação de máquina de
+     * escrever do ChatCustomContent, que reinicia do zero a cada mudança de
+     * conteúdo — com streaming, o texto ficaria piscando e voltando ao início.
+     * A animação agora vem do servidor.
+     */
+    const createAiMessage = (
+        chatId: string,
+        options?: Partial<Conversation>,
     ) => {
-        const resp = await apiPostChat<PostAiChatResponse>({
-            prompt,
-            attachments,
-        })
-        pushConversation(id, {
-            id: uniqueId('ai-conversation-'),
+        const messageId = uniqueId('ai-conversation-')
+        pushConversation(chatId, {
+            id: messageId,
             sender: {
                 id: 'ai',
                 name: 'Chat AI',
                 avatarImageUrl: '/img/thumbs/ai.jpg',
             },
-            content: resp.choices[0].message.content || '',
+            content: '',
             timestamp: dayjs().toDate(),
             type: 'regular',
             isMyMessage: false,
-            fresh: true,
+            fresh: false,
+            ...options,
         })
-        setIsTyping(false)
+        return messageId
     }
 
-    const createConversation = async (
-        id: string,
-        prompt: string,
-        attachments?: File[],
+    /**
+     * Consome um stream escrevendo numa mensagem que já existe.
+     *
+     * Compartilhado pelo envio e pela retomada de aprovação: quando o usuário
+     * aprova, a resposta continua na MESMA mensagem, então o acumulador de
+     * texto e de ferramentas precisa partir do que já está lá.
+     */
+    const consumirStream = async (
+        chatId: string,
+        messageId: string,
+        executar: (onEvent: (evento: ChatEvent) => void) => Promise<void>,
+        inicial: { texto: string; tools: ToolCall[] },
     ) => {
-        setSelectedConversation(id)
-        await sendMessage(id, prompt, attachments)
+        // Acumulados localmente: o store guarda o resultado, mas ler de volta a
+        // cada token para concatenar seria uma corrida com o próprio set().
+        let texto = inicial.texto
+        let tools = inicial.tools
+
+        const aplicar = (evento: ChatEvent) => {
+            switch (evento.type) {
+                case 'token':
+                    texto += evento.data.content
+                    updateConversation(chatId, messageId, { content: texto })
+                    break
+
+                case 'tool_start':
+                    tools = [
+                        ...tools,
+                        {
+                            id: evento.data.id,
+                            name: evento.data.name,
+                            args: evento.data.args,
+                            running: true,
+                        },
+                    ]
+                    updateConversation(chatId, messageId, { tools })
+                    break
+
+                case 'tool_end':
+                    tools = tools.map((tool) =>
+                        tool.id === evento.data.id
+                            ? {
+                                  ...tool,
+                                  running: false,
+                                  awaitingApproval: false,
+                                  result: evento.data.content,
+                                  isError: evento.data.is_error,
+                              }
+                            : tool,
+                    )
+                    updateConversation(chatId, messageId, { tools })
+                    break
+
+                case 'approval_required': {
+                    // O tool_start já marcou estas ferramentas como "running".
+                    // Elas não estão executando: estão paradas esperando o
+                    // clique — senão o chip giraria para sempre.
+                    const pausadas = new Set(
+                        evento.data.calls.map((call) => call.id),
+                    )
+                    tools = tools.map((tool) =>
+                        pausadas.has(tool.id)
+                            ? { ...tool, running: false, awaitingApproval: true }
+                            : tool,
+                    )
+                    updateConversation(chatId, messageId, {
+                        tools,
+                        pendingApproval: evento.data,
+                    })
+                    break
+                }
+
+                case 'input_required':
+                    // Diferente da aprovação, aqui nenhuma ferramenta foi
+                    // pedida ao ERP: o agente só percebeu que faltam campos.
+                    // Por isso não há chip de ferramenta para ajustar.
+                    updateConversation(chatId, messageId, {
+                        pendingInput: evento.data,
+                    })
+                    break
+
+                case 'done':
+                    // O done é a fonte autoritativa do texto DESTA requisição —
+                    // se algum token se perdeu, ele corrige.
+                    //
+                    // Numa retomada, porém, o que o agente disse ANTES da pausa
+                    // não vem nele (o backend acumula as falas por requisição):
+                    // veio em `inicial.texto`. Sem concatenar, a bolha encolhia
+                    // para só a frase final — "Vou criar a área para você…"
+                    // virava "Nada foi criado" — e o agente parecia ter
+                    // esquecido tudo. No primeiro envio `inicial.texto` é '',
+                    // então nada muda ali.
+                    texto = inicial.texto + evento.data.content
+                    updateConversation(chatId, messageId, { content: texto })
+                    break
+
+                case 'error':
+                    updateConversation(chatId, messageId, {
+                        content: evento.data.message || AI_ERROR_MESSAGE,
+                        isError: true,
+                    })
+                    break
+            }
+        }
+
+        try {
+            await executar(aplicar)
+        } catch {
+            updateConversation(chatId, messageId, {
+                content: texto || AI_ERROR_MESSAGE,
+                isError: !texto,
+            })
+        } finally {
+            setIsTyping(false)
+        }
+    }
+
+    const sendMessage = async (chatId: string, prompt: string) => {
+        const messageId = createAiMessage(chatId)
+        await consumirStream(
+            chatId,
+            messageId,
+            (onEvent) => streamChat({ prompt, conversationId: chatId, onEvent }),
+            { texto: '', tools: [] },
+        )
     }
 
-    const handleSend = async (prompt: string, attachments?: File[]) => {
+    const createConversation = async (chatId: string, prompt: string) => {
+        setSelectedConversation(chatId)
+        await sendMessage(chatId, prompt)
+    }
+
+    const handleSend = async (prompt: string) => {
         setIsTyping(true)
         if (selectedConversation) {
             creteMyMessage(selectedConversation, prompt)
             await sendMessage(selectedConversation, prompt)
         } else {
-            const newId = uniqueId('ai-chat-')
+            const newId = novoIdDeConversa()
             pushChatHistory({
                 id: newId,
                 title: prompt,
                 lastConversation: '',
                 createdTime: dayjs().unix(),
                 updatedTime: dayjs().unix(),
-                enable: false,
+                enable: true,
             })
             creteMyMessage(newId, prompt)
-            await createConversation(newId, prompt, attachments)
+            await createConversation(newId, prompt)
         }
     }
 
+    /**
+     * Aprova ou nega a operação pendente e retoma a conversa.
+     *
+     * Continua escrevendo na mesma mensagem: por isso o acumulador parte do
+     * conteúdo e das ferramentas que já estão lá.
+     */
+    const handleApproval = async (
+        chatId: string,
+        messageId: string,
+        approved: boolean,
+    ) => {
+        const mensagem = usGenerativeChatStore
+            .getState()
+            .chatHistory.find((chat) => chat.id === chatId)
+            ?.conversation?.find((item) => item.id === messageId)
+
+        if (!mensagem?.pendingApproval) {
+            return
+        }
+
+        setIsTyping(true)
+        // Some com o card antes da chamada: dois cliques rápidos enviariam duas
+        // retomadas, e a segunda falha (o interrupt já foi consumido).
+        updateConversation(chatId, messageId, { pendingApproval: undefined })
+
+        await consumirStream(
+            chatId,
+            messageId,
+            (onEvent) =>
+                resumeChat({ approved, conversationId: chatId, onEvent }),
+            { texto: mensagem.content ?? '', tools: mensagem.tools ?? [] },
+        )
+    }
+
+    /**
+     * Envia os dados que faltavam (ou o cancelamento) e retoma a conversa.
+     *
+     * Mesma mecânica do `handleApproval`: continua na MESMA mensagem, então o
+     * acumulador parte do que já está lá.
+     */
+    const handleDataSubmit = async (
+        chatId: string,
+        messageId: string,
+        dados: Record<string, unknown> | null,
+    ) => {
+        const mensagem = usGenerativeChatStore
+            .getState()
+            .chatHistory.find((chat) => chat.id === chatId)
+            ?.conversation?.find((item) => item.id === messageId)
+
+        if (!mensagem?.pendingInput) {
+            return
+        }
+
+        setIsTyping(true)
+        // Some com o formulário antes da chamada: dois envios mandariam duas
+        // retomadas, e a segunda falha (o interrupt já foi consumido).
+        updateConversation(chatId, messageId, { pendingInput: undefined })
+
+        await consumirStream(
+            chatId,
+            messageId,
+            (onEvent) => resumeChat({ dados, conversationId: chatId, onEvent }),
+            { texto: mensagem.content ?? '', tools: mensagem.tools ?? [] },
+        )
+    }
+
     return {
         handleSend,
+        handleApproval,
+        handleDataSubmit,
     }
 }
 

package/lib/@ecme/views/concepts/ai/Chat/hooks/useConversationMessages.ts

@@ -0,0 +1,68 @@
+import { useEffect, useState } from 'react'
+import { apiGetChatHistory } from '@/services/AiService'
+import { usGenerativeChatStore } from '../store/generativeChatStore'
+import { mensagemDoHistorico } from '../utils'
+import type { Conversation, HistoryChat } from '../types'
+
+/**
+ * Busca as mensagens da conversa selecionada quando ela veio da lista do
+ * backend e ainda não foi aberta nesta sessão.
+ *
+ * Busca uma vez por conversa: depois disso `loaded` fica true e as mensagens
+ * novas chegam pelo streaming, como em qualquer conversa.
+ */
+const useConversationMessages = () => {
+    const { selectedConversation, chatHistory, setConversationMessages } =
+        usGenerativeChatStore()
+    const [carregando, setCarregando] = useState(false)
+
+    const pendente =
+        chatHistory.find((chat) => chat.id === selectedConversation)?.loaded ===
+        false
+
+    useEffect(() => {
+        if (!selectedConversation || !pendente) {
+            return
+        }
+
+        // Trocar de conversa no meio da busca não pode gravar a resposta
+        // atrasada na tela errada.
+        let cancelado = false
+        setCarregando(true)
+
+        // O usuário pode ter enviado algo enquanto a busca corria: o que já
+        // está na tela vem depois do histórico, e não some.
+        const gravar = (antigas: Conversation[]) => {
+            const naTela =
+                usGenerativeChatStore
+                    .getState()
+                    .chatHistory.find((chat) => chat.id === selectedConversation)
+                    ?.conversation ?? []
+            setConversationMessages(selectedConversation, [...antigas, ...naTela])
+        }
+
+        apiGetChatHistory<HistoryChat[]>(selectedConversation)
+            .then((resposta) => {
+                if (cancelado) return
+                gravar((resposta[0]?.conversation ?? []).map(mensagemDoHistorico))
+            })
+            .catch(() => {
+                // Marca como carregada mesmo assim: sem isto, cada render
+                // tentaria de novo. A conversa segue utilizável, porque a
+                // memória está no backend.
+                if (!cancelado) gravar([])
+            })
+            .finally(() => {
+                if (!cancelado) setCarregando(false)
+            })
+
+        return () => {
+            cancelado = true
+            setCarregando(false)
+        }
+    }, [selectedConversation, pendente, setConversationMessages])
+
+    return { carregando }
+}
+
+export default useConversationMessages

package/lib/@ecme/views/concepts/ai/Chat/store/generativeChatStore.ts

@@ -1,4 +1,5 @@
 import { create } from 'zustand'
+import { useSessionUser } from '@/store/authStore'
 import type { ChatHistories, ChatHistory, Conversation } from '../types'
 
 type RenameDialog = {
@@ -24,7 +25,16 @@ type GenerativeChatAction = {
     setIsTyping: (payload: boolean) => void
     pushChatHistory: (payload: ChatHistory) => void
     pushConversation: (id: string, conversation: Conversation) => void
+    /** Grava as mensagens buscadas no backend e marca a conversa como carregada. */
+    setConversationMessages: (id: string, conversation: Conversation[]) => void
+    updateConversation: (
+        chatId: string,
+        messageId: string,
+        patch: Partial<Conversation>,
+    ) => void
     disabledChatFresh: (id: string) => void
+    /** Volta ao estado inicial. Chamado sozinho quando o usuário da sessão muda. */
+    reset: () => void
 }
 
 const initialState: GenerativeChatState = {
@@ -43,6 +53,14 @@ export const usGenerativeChatStore = create<
     GenerativeChatState & GenerativeChatAction
 >((set, get) => ({
     ...initialState,
+    // Arrays novos: `setSelectedConversationRecord` muta o array no lugar, e
+    // reusar o do initialState traria de volta o que ele acumulou.
+    reset: () =>
+        set(() => ({
+            ...initialState,
+            selectedConversationRecord: [],
+            chatHistory: [],
+        })),
     setSelectedConversation: (payload) =>
         set(() => ({ selectedConversation: payload })),
     setChatHistory: (payload) => set(() => ({ chatHistory: payload })),
@@ -69,21 +87,54 @@ export const usGenerativeChatStore = create<
 
             return { selectedConversationRecord: record }
         }),
+    // Conversa criada nesta sessão já nasce carregada: as mensagens estão aqui,
+    // não há o que buscar no backend.
     pushChatHistory: (payload) =>
-        set(() => ({ chatHistory: [...[payload], ...get().chatHistory] })),
+        set(() => ({
+            chatHistory: [{ loaded: true, ...payload }, ...get().chatHistory],
+        })),
+    setConversationMessages: (id, conversation) =>
+        set(() => ({
+            chatHistory: get().chatHistory.map((chat) =>
+                chat.id === id ? { ...chat, conversation, loaded: true } : chat,
+            ),
+        })),
     pushConversation: (id, conversation) =>
-        set(() => {
-            const chatHistory = get().chatHistory.map((chat) => {
-                if (chat.id === id) {
-                    if (!chat.conversation) {
-                        chat.conversation = []
-                    }
-                    chat.conversation?.push(conversation)
-                }
-                return chat
-            })
-            return { chatHistory }
-        }),
+        set(() => ({
+            chatHistory: get().chatHistory.map((chat) =>
+                chat.id === id
+                    ? {
+                          ...chat,
+                          conversation: [
+                              ...(chat.conversation ?? []),
+                              conversation,
+                          ],
+                      }
+                    : chat,
+            ),
+        })),
+    /**
+     * Atualiza UMA mensagem de uma conversa.
+     *
+     * Imutavel de proposito: o streaming chama isto a cada token, e mutar o
+     * objeto no lugar faria o React perder atualizacoes — a re-renderizacao
+     * dependeria da identidade do array externo mudar por acaso.
+     */
+    updateConversation: (chatId, messageId, patch) =>
+        set(() => ({
+            chatHistory: get().chatHistory.map((chat) =>
+                chat.id === chatId
+                    ? {
+                          ...chat,
+                          conversation: chat.conversation?.map((mensagem) =>
+                              mensagem.id === messageId
+                                  ? { ...mensagem, ...patch }
+                                  : mensagem,
+                          ),
+                      }
+                    : chat,
+            ),
+        })),
     setIsTyping: (payload) => set(() => ({ isTyping: payload })),
     disabledChatFresh: () =>
         set(() => {
@@ -103,3 +154,23 @@ export const usGenerativeChatStore = create<
             return { chatHistory }
         }),
 }))
+
+/**
+ * O chat pertence ao usuário da sessão: trocou o usuário, zera o chat.
+ *
+ * Login e logout acontecem sem recarregar a página, e este store é um singleton
+ * do módulo. Sem isto, o próximo usuário via as conversas do anterior.
+ *
+ * Olha o `signedIn` além do `userId` porque o logout faz `setUser({})`, e o
+ * `setUser` faz MERGE: o `userId` antigo continua lá depois de sair.
+ *
+ * É uma assinatura, e não um efeito de componente, para zerar ANTES do próximo
+ * render: a lista antiga nem chega a piscar na tela.
+ */
+useSessionUser.subscribe((atual, anterior) => {
+    const trocouUsuario = atual.user.userId !== anterior.user.userId
+    const saiu = anterior.session.signedIn && !atual.session.signedIn
+    if (trocouUsuario || saiu) {
+        usGenerativeChatStore.getState().reset()
+    }
+})