@orbe-agro/client-core 5.6.260 → 5.6.262

package/lib/@ecme/views/concepts/ai/Chat/components/ChatView.tsx

@@ -5,37 +5,15 @@ import ChatLandingView from './ChatLandingView'
 import ChatMobileNav from './ChatMobileNav'
 import ChatCustomContent from './ChatCustomContent'
 import ChatCustomAction from './ChatCustomAction'
-import AiThinkingIndicator from './AiThinkingIndicator'
-import AiErrorMessage from './AiErrorMessage'
-import ToolCallChip from './ToolCallChip'
-import ApprovalCard from './ApprovalCard'
-import DataRequestCard from './DataRequestCard'
 import { usGenerativeChatStore } from '../store/generativeChatStore'
 import useChatSend from '../hooks/useChatSend'
-import type { Conversation } from '../types'
 import type { ScrollBarRef } from '@/components/ui/ScrollBar'
 
-/**
- * O balao de fala do agente, desenhado aqui em vez de vir do ChatBox.
- *
- * O `botBubbleClass` abaixo zera o balao que o Message desenharia, para os chips
- * de ferramenta e o card de aprovacao ficarem FORA dele — antes tudo dividia a
- * mesma caixa cinza e as ferramentas eram lidas como uma segunda mensagem.
- * Usado tambem pelo indicador de "pensando", que passa pelo mesmo balao zerado.
- *
- * Repete `prose text-sm` do balao original de proposito: o reset de margem do
- * @tailwindcss/typography e `.prose > :first-child`, filho DIRETO. Sem o `prose`
- * aqui, o markdown ficaria um nivel abaixo do container e o primeiro paragrafo
- * voltaria a ter margem, inflando todos os baloes.
- */
-const BALAO_AGENTE =
-    'prose rounded-xl bg-gray-100 px-5 py-2.5 text-sm text-gray-900 dark:bg-gray-700 dark:text-gray-100'
-
 const ChatView = () => {
     const scrollRef = useRef<ScrollBarRef>(null)
     const { selectedConversation, chatHistory, isTyping, disabledChatFresh } =
         usGenerativeChatStore()
-    const { handleSend, handleApproval, handleDataSubmit } = useChatSend()
+    const { handleSend } = useChatSend()
 
     const scrollToBottom = () => {
         if (scrollRef.current?.getScrollElement) {
@@ -77,18 +55,10 @@ const ChatView = () => {
             <ChatBox
                 ref={scrollRef}
                 messageList={messageList}
-                placeholder="Pergunte algo sobre o Orbe Agro…"
+                placeholder="Enter a prompt here"
                 showMessageList={Boolean(selectedConversation)}
-                showAvatar={false}
-                avatarGap={false}
-                myBubbleClass="bg-primary text-white"
-                botBubbleClass="bg-transparent dark:bg-transparent p-0 rounded-none"
-                errorBubbleClass="bg-red-50 dark:bg-red-500/10 border border-red-200 dark:border-red-500/20"
-                renderTyping={() => (
-                    <div className={BALAO_AGENTE}>
-                        <AiThinkingIndicator />
-                    </div>
-                )}
+                showAvatar={true}
+                avatarGap={true}
                 containerClass="h-[calc(100%-30px)] xl:h-full"
                 messageListClass="h-[calc(100%-100px)] xl:h-[calc(100%-70px)]"
                 typing={
@@ -101,73 +71,22 @@ const ChatView = () => {
                         : false
                 }
                 customRenderer={(message) => {
-                    if (message.isError) {
-                        return <AiErrorMessage />
-                    }
-
                     if (message.sender.id === 'ai') {
-                        // As ferramentas e as pausas chegam pelo streaming e
-                        // vivem no Conversation; o tipo do ChatBox nao os conhece.
-                        const { tools, pendingApproval, pendingInput } =
-                            message as Conversation
-                        // Enquanto as ferramentas rodam o conteudo ainda e '':
-                        // sem esta guarda sobraria um balao cinza vazio.
-                        const temTexto = Boolean(
-                            (message.content as string)?.trim(),
-                        )
-
                         return (
-                            <div className="flex flex-col items-start gap-1.5">
-                                {tools?.map((tool) => (
-                                    <ToolCallChip key={tool.id} tool={tool} />
-                                ))}
-                                {temTexto && (
-                                    <div className={BALAO_AGENTE}>
-                                        <ChatCustomContent
-                                            content={message.content as string}
-                                            triggerTyping={
-                                                message.fresh
-                                                    ? message.fresh
-                                                    : false
-                                            }
-                                            onFinish={() =>
-                                                handleFinish(message.id)
-                                            }
-                                        />
-                                    </div>
-                                )}
-                                {pendingInput && (
-                                    <DataRequestCard
-                                        input={pendingInput}
-                                        onSubmit={(dados) =>
-                                            handleDataSubmit(
-                                                selectedConversation,
-                                                message.id,
-                                                dados,
-                                            )
-                                        }
-                                    />
-                                )}
-                                {pendingApproval && (
-                                    <ApprovalCard
-                                        approval={pendingApproval}
-                                        onDecide={(aprovado) =>
-                                            handleApproval(
-                                                selectedConversation,
-                                                message.id,
-                                                aprovado,
-                                            )
-                                        }
-                                    />
-                                )}
-                            </div>
+                            <ChatCustomContent
+                                content={message.content as string}
+                                triggerTyping={
+                                    message.fresh ? message.fresh : false
+                                }
+                                onFinish={() => handleFinish(message.id)}
+                            />
                         )
                     }
 
                     return message.content
                 }}
                 customAction={(message) => {
-                    if (message.sender.id === 'ai' && !message.isError) {
+                    if (message.sender.id === 'ai') {
                         return (
                             <ChatCustomAction
                                 content={message.content as string}
@@ -179,11 +98,7 @@ const ChatView = () => {
                 }}
                 onInputChange={handleInputChange}
             >
-                {!selectedConversation && (
-                    <div className="flex-1 min-h-0 overflow-y-auto">
-                        <ChatLandingView />
-                    </div>
-                )}
+                {!selectedConversation && <ChatLandingView />}
             </ChatBox>
         </Card>
     )

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

@@ -1,22 +1,15 @@
 import { usGenerativeChatStore } from '../store/generativeChatStore'
-import { resumeChat, streamChat } from '@/services/AiService'
-import { useAuth } from '@/auth'
+import { apiPostChat } from '@/services/AiService'
 import dayjs from 'dayjs'
 import uniqueId from 'lodash/uniqueId'
-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.'
+import type { PostAiChatResponse } from '../types'
 
 const useChatSend = () => {
-    const { user } = useAuth()
     const {
         selectedConversation,
         setSelectedConversation,
         pushChatHistory,
         pushConversation,
-        updateConversation,
         setIsTyping,
     } = usGenerativeChatStore()
 
@@ -24,9 +17,9 @@ const useChatSend = () => {
         pushConversation(id, {
             id: uniqueId('ai-conversation-'),
             sender: {
-                id: user.userId ?? 'me',
-                name: user.userName ?? 'Você',
-                avatarImageUrl: user.avatar ?? undefined,
+                id: '1',
+                name: 'Angelina Gotelli',
+                avatarImageUrl: '/img/avatars/thumb-1.jpg',
             },
             content: prompt,
             timestamp: dayjs().toDate(),
@@ -35,169 +28,41 @@ const useChatSend = () => {
         })
     }
 
-    /**
-     * 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 sendMessage = async (
+        id: string,
+        prompt: string,
+        attachments?: File[],
     ) => {
-        const messageId = uniqueId('ai-conversation-')
-        pushConversation(chatId, {
-            id: messageId,
+        const resp = await apiPostChat<PostAiChatResponse>({
+            prompt,
+            attachments,
+        })
+        pushConversation(id, {
+            id: uniqueId('ai-conversation-'),
             sender: {
                 id: 'ai',
                 name: 'Chat AI',
                 avatarImageUrl: '/img/thumbs/ai.jpg',
             },
-            content: '',
+            content: resp.choices[0].message.content || '',
             timestamp: dayjs().toDate(),
             type: 'regular',
             isMyMessage: false,
-            fresh: false,
-            ...options,
+            fresh: true,
         })
-        return messageId
+        setIsTyping(false)
     }
 
-    /**
-     * 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[] },
+    const createConversation = async (
+        id: string,
+        prompt: string,
+        attachments?: File[],
     ) => {
-        // 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: [] },
-        )
+        setSelectedConversation(id)
+        await sendMessage(id, prompt, attachments)
     }
 
-    const createConversation = async (chatId: string, prompt: string) => {
-        setSelectedConversation(chatId)
-        await sendMessage(chatId, prompt)
-    }
-
-    const handleSend = async (prompt: string) => {
+    const handleSend = async (prompt: string, attachments?: File[]) => {
         setIsTyping(true)
         if (selectedConversation) {
             creteMyMessage(selectedConversation, prompt)
@@ -213,81 +78,12 @@ const useChatSend = () => {
                 enable: false,
             })
             creteMyMessage(newId, prompt)
-            await createConversation(newId, prompt)
+            await createConversation(newId, prompt, attachments)
         }
     }
 
-    /**
-     * 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/store/generativeChatStore.ts

@@ -24,11 +24,6 @@ type GenerativeChatAction = {
     setIsTyping: (payload: boolean) => void
     pushChatHistory: (payload: ChatHistory) => void
     pushConversation: (id: string, conversation: Conversation) => void
-    updateConversation: (
-        chatId: string,
-        messageId: string,
-        patch: Partial<Conversation>,
-    ) => void
     disabledChatFresh: (id: string) => void
 }
 
@@ -75,43 +70,20 @@ export const usGenerativeChatStore = create<
             return { selectedConversationRecord: record }
         }),
     pushChatHistory: (payload) =>
-        set(() => ({ chatHistory: [payload, ...get().chatHistory] })),
+        set(() => ({ chatHistory: [...[payload], ...get().chatHistory] })),
     pushConversation: (id, conversation) =>
-        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,
-            ),
-        })),
+        set(() => {
+            const chatHistory = get().chatHistory.map((chat) => {
+                if (chat.id === id) {
+                    if (!chat.conversation) {
+                        chat.conversation = []
+                    }
+                    chat.conversation?.push(conversation)
+                }
+                return chat
+            })
+            return { chatHistory }
+        }),
     setIsTyping: (payload) => set(() => ({ isTyping: payload })),
     disabledChatFresh: () =>
         set(() => {

package/lib/@ecme/views/concepts/ai/Chat/types.ts

@@ -1,40 +1,3 @@
-/** Uma ferramenta que o agente chamou durante a resposta. */
-export type ToolCall = {
-    id: string
-    name: string
-    args: Record<string, unknown>
-    /** Retorno da ferramenta; so existe depois do tool_end. */
-    result?: string
-    isError?: boolean
-    /** true enquanto a ferramenta esta executando. */
-    running: boolean
-    /**
-     * true quando a ferramenta esta parada esperando o usuario aprovar.
-     *
-     * O backend emite `tool_start` assim que o modelo DECIDE chamar a
-     * ferramenta — antes de saber se ela precisa de aprovacao. Sem esta flag, o
-     * chip ficaria girando "executando" enquanto na verdade espera um clique.
-     */
-    awaitingApproval?: boolean
-}
-
-/** Operacao de escrita parada, esperando o usuario aprovar ou negar. */
-export type PendingApproval = {
-    id: string
-    calls: { id: string; name: string; args: Record<string, unknown> }[]
-}
-
-/**
- * Criacao parada por falta de dados, esperando o usuario preencher.
- *
- * `campos` traz os nomes TECNICOS dos parametros que faltam (ex.:
- * `produto_id`); quem exibe traduz com `rotularCampo`.
- */
-export type PendingInput = {
-    id: string
-    campos: string[]
-}
-
 export type Conversation = {
     id: string
     sender: {
@@ -51,77 +14,38 @@ export type Conversation = {
         mediaUrl: string
     }>
     isMyMessage?: boolean
-    /**
-     * Liga a animacao de maquina de escrever do ChatCustomContent.
-     *
-     * Mensagens vindas do streaming devem usar `false`: o texto ja chega
-     * progressivamente do servidor, e a animacao reinicia do zero a cada token
-     * novo (ela reseta a posicao quando o conteudo muda).
-     */
     fresh?: boolean
-    isError?: boolean
-    /** Ferramentas chamadas pelo agente nesta resposta. */
-    tools?: ToolCall[]
-    /** Preenchido quando o agente pausou esperando aprovacao humana. */
-    pendingApproval?: PendingApproval
-    /** Preenchido quando o agente pausou pedindo os dados que faltam. */
-    pendingInput?: PendingInput
 }
 
-/**
- * Eventos do stream de /ai/chat/stream.
- *
- * Ordem tipica de uma resposta que consulta o ERP:
- *
- *     token*  tool_start  tool_end  token*  done
- *
- * `done` sempre fecha o stream e traz a resposta final completa. Concatenar os
- * `token` da o mesmo texto — o front pode usar qualquer um dos dois caminhos.
- */
-export type ChatEvent =
-    | { type: 'token'; data: { content: string } }
-    | {
-          type: 'tool_start'
-          data: { id: string; name: string; args: Record<string, unknown> }
-      }
-    | {
-          type: 'tool_end'
-          data: {
-              id: string
-              name: string
-              content: string
-              is_error: boolean
-          }
-      }
-    | {
-          /**
-           * O agente parou antes de uma operacao de escrita e espera decisao.
-           *
-           * Quando este evento chega, o `done` NAO vem: o turno nao terminou,
-           * esta pausado. Retomar e chamar `resumeChat`.
-           */
-          type: 'approval_required'
-          data: {
-              id: string
-              calls: {
-                  id: string
-                  name: string
-                  args: Record<string, unknown>
-              }[]
-          }
-      }
-    | {
-          /**
-           * Faltam campos para criar: o agente parou esperando o formulario.
-           *
-           * Como no `approval_required`, o `done` NAO vem — o turno esta
-           * pausado. Retomar e chamar `resumeChat({ dados })`.
-           */
-          type: 'input_required'
-          data: { id: string; campos: string[] }
-      }
-    | { type: 'done'; data: { content: string } }
-    | { type: 'error'; data: { message: string } }
+export type PostAiChatResponse = {
+    id: string
+    choices: {
+        finish_reason:
+            | 'stop'
+            | 'length'
+            | 'tool_calls'
+            | 'content_filter'
+            | 'function_call'
+        index: number
+        logprobs: {
+            content: Array<{
+                token: string
+                bytes: Array<number> | null
+                top_logprobs: Array<{
+                    token: string
+                    bytes: Array<number> | null
+                    logprob: number
+                }>
+            }>
+        } | null
+        message: {
+            content: string | null
+            role: string
+        }
+    }[]
+    created: number
+    model: string
+}
 
 export type ChatHistory = {
     id: string