@orbe-agro/client-core 5.6.262 → 5.6.264

package/lib/@ecme/configs/navigation.config/concepts.navigation.config.ts

@@ -38,22 +38,6 @@ const conceptsNavigationConfig: NavigationTree[] = [
                     },
                 },
                 subMenu: [
-                    {
-                        key: 'concepts.ai.chat',
-                        path: `${CONCEPTS_PREFIX_PATH}/ai/chat`,
-                        title: 'Chat',
-                        translateKey: 'nav.conceptsAi.chat',
-                        icon: 'aiChat',
-                        type: NAV_ITEM_TYPE_ITEM,
-                        authority: [ADMIN, USER],
-                        meta: {
-                            description: {
-                                translateKey: 'nav.conceptsAi.chatDesc',
-                                label: 'AI-powered chat systems',
-                            },
-                        },
-                        subMenu: [],
-                    },
                     {
                         key: 'concepts.ai.image',
                         path: `${CONCEPTS_PREFIX_PATH}/ai/image`,

package/lib/@ecme/configs/routes.config/conceptsRoute.ts

@@ -4,15 +4,6 @@ import { ADMIN, USER } from '@/constants/roles.constant'
 import type { Routes } from '@/@types/routes'
 
 const conceptsRoute: Routes = [
-    {
-        key: 'concepts.ai.chat',
-        path: `${CONCEPTS_PREFIX_PATH}/ai/chat`,
-        component: lazy(() => import('@/views/concepts/ai/Chat')),
-        authority: [ADMIN, USER],
-        meta: {
-            pageContainerType: 'contained',
-        },
-    },
     {
         key: 'concepts.ai.image',
         path: `${CONCEPTS_PREFIX_PATH}/ai/image`,

package/lib/@ecme/locales/index.ts

@@ -1,8 +1,4 @@
 import i18n from './locales'
 
 export { dateLocales } from './locales'
-export {
-	ensureAppLocaleResourcesLoaded,
-	initAllAppLocaleResources,
-} from './initAll'
 export default i18n

package/lib/@ecme/locales/lang/ptBR/nav.ts

@@ -62,6 +62,7 @@ export default {
                 vinculoUnidadeMedida: 'Vínculo de Unidade de Medida',
                 vinculoOperacao: 'Vínculo de Operação',
                 vinculoIva: 'Vínculo de IVA',
+                cfop: 'CFOP',
                 notificacaoCentralNfe: 'Notificação Central NFe',
                 nfe: 'NFe',
                 intervaloPrecoXml: 'Intervalo Preço XML',

package/lib/@ecme/mock/data/favoritosMenuData.ts

@@ -0,0 +1,3 @@
+import { TFavoritoMenuResponse } from '@base/@types/api/response/dadosMestres/TFavoritoMenuResponse'
+
+export const favoritosMenuData: TFavoritoMenuResponse[] = []

package/lib/@ecme/services/AiService.ts

@@ -1,27 +1,179 @@
+import { authHeaders } from './aiAuthHeaders'
 import ApiService from './ApiService'
+import { readSse } from './sseParser'
+import type { ChatEvent } from '@/views/concepts/ai/Chat/types'
+import type { AxiosRequestConfig } from 'axios'
 
-export async function apiPostChat<T>(data: {
-    prompt: string
-    attachments?: File[]
-}) {
-    return ApiService.fetchDataWithAxios<T>({
-        url: '/ai/chat',
-        method: 'post',
-        data,
-    })
+const AI_DEV_URL = 'http://localhost:8000'
+const AI_BUILD_URL = 'https://orbe-ai.apps.qas.orbeagro.com.br'
+
+/**
+ * Host da API de IA.
+ *
+ * O /ai/* nao vive no gateway do resto da aplicacao, entao nao pode usar o
+ * baseURL do AxiosBase (API_URL). A resolucao e por origin em runtime, e nao
+ * por import.meta.env.MODE, porque o MODE e congelado na build da lib como
+ * "production" e nao reflete o dev do MFE consumidor.
+ */
+function getAiApiUrl() {
+    const origin = globalThis?.location?.origin ?? ''
+
+    if (origin.includes('localhost') || origin.includes('127.0.0.1')) {
+        return AI_DEV_URL
+    }
+
+    // QAS e PRD compartilham a mesma URL por enquanto. Quando houver uma URL
+    // de PRD, o split entra aqui: if (origin.includes('.prd.')) return AI_PRD_URL
+    return AI_BUILD_URL
 }
 
-export async function apiGetChatHistory<T>() {
-    return ApiService.fetchDataWithAxios<T>({
+export const AI_API_URL = getAiApiUrl()
+
+/**
+ * Toda chamada de IA sai pelo AI_API_URL (o baseURL por requisicao vence o da
+ * instancia do AxiosBase) e fica fora do loading global — o chat mostra o
+ * proprio balaozinho de "digitando".
+ */
+const aiRequest = <T>(config: AxiosRequestConfig) =>
+    ApiService.fetchDataWithAxios<T>({
+        ...config,
+        baseURL: AI_API_URL,
+        skipGlobalLoading: true,
+    })
+
+export async function apiGetChatHistory<T>(conversationId?: string) {
+    return aiRequest<T>({
         url: '/ai/chat/history',
         method: 'get',
+        params: conversationId ? { conversation_id: conversationId } : undefined,
+    })
+}
+
+/** Conversas do usuário (só o resumo), a mais recente primeiro. */
+export async function apiGetConversations<T>() {
+    return aiRequest<T>({
+        url: '/ai/chat/conversations',
+        method: 'get',
+    })
+}
+
+export async function apiRenameConversation(conversationId: string, title: string) {
+    return aiRequest<void>({
+        url: `/ai/chat/conversations/${encodeURIComponent(conversationId)}`,
+        method: 'patch',
+        data: { title },
+    })
+}
+
+/** Apaga a conversa e toda a memória dela no backend. */
+export async function apiDeleteConversation(conversationId: string) {
+    return aiRequest<void>({
+        url: `/ai/chat/conversations/${encodeURIComponent(conversationId)}`,
+        method: 'delete',
+    })
+}
+
+export type StreamChatParams = {
+    prompt: string
+    /** Identifica a conversa; o backend usa como thread da memoria. */
+    conversationId?: string
+    signal?: AbortSignal
+    onEvent: (evento: ChatEvent) => void
+}
+
+/**
+ * Resposta a pausa atual do agente. Ha duas, e um endpoint so:
+ * - `approved` responde ao `approval_required` (true aprova, false nega).
+ * - `dados` responde ao `input_required`; `null` = o usuario fechou o
+ *   formulario sem preencher.
+ */
+export type ResumeChatParams = {
+    approved?: boolean
+    dados?: Record<string, unknown> | null
+    conversationId?: string
+    signal?: AbortSignal
+    onEvent: (evento: ChatEvent) => void
+}
+
+/**
+ * Envia a mensagem e consome a resposta em streaming (SSE).
+ *
+ * Usa `fetch`, e nao o Axios, porque o Axios no browser so resolve a Promise
+ * com a resposta inteira — nao ha como ler o corpo enquanto ele chega.
+ */
+export async function streamChat({
+    prompt,
+    conversationId,
+    signal,
+    onEvent,
+}: StreamChatParams): Promise<void> {
+    await postarEConsumir(
+        '/ai/chat/stream',
+        { prompt, conversation_id: conversationId },
+        onEvent,
+        signal,
+    )
+}
+
+/**
+ * Retoma uma conversa parada numa pausa (aprovacao ou coleta de dados).
+ *
+ * Devolve o mesmo tipo de stream do `streamChat`, e a resposta continua na
+ * MESMA mensagem do chat — o backend so volta do ponto onde parou.
+ *
+ * O `JSON.stringify` descarta chaves `undefined`, entao o backend recebe apenas
+ * o campo da pausa que esta sendo respondida.
+ */
+export async function resumeChat({
+    approved,
+    dados,
+    conversationId,
+    signal,
+    onEvent,
+}: ResumeChatParams): Promise<void> {
+    await postarEConsumir(
+        '/ai/chat/resume',
+        { approved, dados, conversation_id: conversationId },
+        onEvent,
+        signal,
+    )
+}
+
+/** POST + leitura do SSE, comum ao envio e a retomada. */
+async function postarEConsumir(
+    caminho: string,
+    corpo: Record<string, unknown>,
+    onEvent: (evento: ChatEvent) => void,
+    signal?: AbortSignal,
+): Promise<void> {
+    const resposta = await fetch(`${AI_API_URL}${caminho}`, {
+        method: 'POST',
+        headers: {
+            ...authHeaders(),
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(corpo),
+        signal,
+    })
+
+    if (!resposta.ok || !resposta.body) {
+        throw new Error(`Falha ao falar com a IA (HTTP ${resposta.status})`)
+    }
+
+    await readSse(resposta.body, ({ event, data }) => {
+        try {
+            onEvent({ type: event, data: JSON.parse(data) } as ChatEvent)
+        } catch (error) {
+            // Evento malformado nao pode derrubar o stream inteiro.
+            console.debug('Evento SSE ignorado:', event, error)
+        }
     })
 }
 
 export async function apiGetImages<T, U extends Record<string, unknown>>(
     params: U,
 ) {
-    return ApiService.fetchDataWithAxios<T>({
+    return aiRequest<T>({
         url: '/ai/images',
         method: 'get',
         params,
@@ -31,7 +183,7 @@ export async function apiGetImages<T, U extends Record<string, unknown>>(
 export async function apiPostImages<T, U extends Record<string, unknown>>(
     data: U,
 ) {
-    return ApiService.fetchDataWithAxios<T>({
+    return aiRequest<T>({
         url: '/ai/images',
         method: 'post',
         data,

package/lib/@ecme/services/aiAuthHeaders.ts

@@ -0,0 +1,58 @@
+import appConfig from '@/configs/app.config'
+import {
+    REQUEST_HEADER_AUTH_KEY,
+    TOKEN_NAME_IN_STORAGE,
+    TOKEN_TYPE,
+} from '@/constants/api.constant'
+
+/**
+ * Headers de autenticacao lidos do storage.
+ *
+ * Existe porque o chat de IA usa `fetch` (o Axios nao faz streaming no
+ * browser) e portanto nao passa pelo interceptor. Em vez de duplicar as regras
+ * de onde mora o token, o interceptor e o fetch chamam esta funcao — uma
+ * verdade so.
+ *
+ * Ver AxiosRequestIntrceptorConfigCallback, que a consome.
+ */
+export const authHeaders = (): Record<string, string> => {
+    const storage = appConfig.accessTokenPersistStrategy
+    const headers: Record<string, string> = {}
+
+    if (storage !== 'localStorage' && storage !== 'sessionStorage') {
+        return headers
+    }
+
+    const source = storage === 'localStorage' ? localStorage : sessionStorage
+    const accessToken = source.getItem(TOKEN_NAME_IN_STORAGE) || ''
+
+    if (accessToken) {
+        headers[REQUEST_HEADER_AUTH_KEY] = `${TOKEN_TYPE}${accessToken}`
+    }
+
+    const userId = readUserId()
+    if (userId) {
+        headers['X-User-Id'] = userId
+    }
+
+    return headers
+}
+
+/**
+ * userId da sessao persistida pelo zustand.
+ *
+ * Silencioso em caso de erro: um storage corrompido nao pode derrubar a
+ * requisicao — sem o header, o backend apenas trata o usuario como desconhecido.
+ */
+const readUserId = (): string | undefined => {
+    try {
+        const raw = localStorage.getItem('SessionUserPageStore')
+        if (!raw) {
+            return undefined
+        }
+        return JSON.parse(raw)?.state?.user?.userId
+    } catch (error) {
+        console.debug('Could not read userId from session store:', error)
+        return undefined
+    }
+}

package/lib/@ecme/services/axios/AxiosBase.ts

@@ -6,6 +6,19 @@ import { useLoadingConfigStore, getCurrentMicrofrontendId } from "@base/store";
 import AxiosRequestIntrceptorConfigCallback from "./AxiosRequestIntrceptorConfigCallback";
 import AxiosResponseIntrceptorErrorCallback from "./AxiosResponseIntrceptorErrorCallback";
 
+/**
+ * Permite que uma requisição específica seja excluída do loading global
+ * (overlay de tela cheia). Útil para chamadas que exibem seu próprio
+ * indicador de carregamento — ex.: o chat de IA, que mostra o balãozinho
+ * de "digitando". Comportamento padrão inalterado: só afeta requisições
+ * que marcarem explicitamente `skipGlobalLoading: true`.
+ */
+declare module "axios" {
+  interface AxiosRequestConfig {
+    skipGlobalLoading?: boolean;
+  }
+}
+
 const AxiosBase = axios.create({
   timeout: 600000,
   baseURL: API_URL,
@@ -13,25 +26,37 @@ const AxiosBase = axios.create({
 
 let activeRequests = 0;
 
+const startGlobalLoading = () => {
+  const microfrontendId = getCurrentMicrofrontendId();
+  const loadingConfig = useLoadingConfigStore.getState();
+  if (loadingConfig.getGlobalLoadingEnabled(microfrontendId)) {
+    useThemeStore.getState().setLoading(true);
+  }
+};
+
+const stopGlobalLoading = () => {
+  const microfrontendId = getCurrentMicrofrontendId();
+  const loadingConfig = useLoadingConfigStore.getState();
+  if (loadingConfig.getGlobalLoadingEnabled(microfrontendId)) {
+    useThemeStore.getState().setLoading(false);
+  }
+};
+
 AxiosBase.interceptors.request.use(
   (config) => {
-    activeRequests++;
-    if (activeRequests === 1) {
-      const microfrontendId = getCurrentMicrofrontendId();
-      const loadingConfig = useLoadingConfigStore.getState();
-      if (loadingConfig.getGlobalLoadingEnabled(microfrontendId)) {
-        useThemeStore.getState().setLoading(true);
+    if (!config.skipGlobalLoading) {
+      activeRequests++;
+      if (activeRequests === 1) {
+        startGlobalLoading();
       }
     }
     return AxiosRequestIntrceptorConfigCallback(config);
   },
   (error) => {
-    activeRequests = Math.max(0, activeRequests - 1);
-    if (activeRequests === 0) {
-      const microfrontendId = getCurrentMicrofrontendId();
-      const loadingConfig = useLoadingConfigStore.getState();
-      if (loadingConfig.getGlobalLoadingEnabled(microfrontendId)) {
-        useThemeStore.getState().setLoading(false);
+    if (!error?.config?.skipGlobalLoading) {
+      activeRequests = Math.max(0, activeRequests - 1);
+      if (activeRequests === 0) {
+        stopGlobalLoading();
       }
     }
     return Promise.reject(error);
@@ -40,23 +65,19 @@ AxiosBase.interceptors.request.use(
 
 AxiosBase.interceptors.response.use(
   (response) => {
-    activeRequests = Math.max(0, activeRequests - 1);
-    if (activeRequests === 0) {
-      const microfrontendId = getCurrentMicrofrontendId();
-      const loadingConfig = useLoadingConfigStore.getState();
-      if (loadingConfig.getGlobalLoadingEnabled(microfrontendId)) {
-        useThemeStore.getState().setLoading(false);
+    if (!response.config?.skipGlobalLoading) {
+      activeRequests = Math.max(0, activeRequests - 1);
+      if (activeRequests === 0) {
+        stopGlobalLoading();
       }
     }
     return response;
   },
   (error: AxiosError) => {
-    activeRequests = Math.max(0, activeRequests - 1);
-    if (activeRequests === 0) {
-      const microfrontendId = getCurrentMicrofrontendId();
-      const loadingConfig = useLoadingConfigStore.getState();
-      if (loadingConfig.getGlobalLoadingEnabled(microfrontendId)) {
-        useThemeStore.getState().setLoading(false);
+    if (!error.config?.skipGlobalLoading) {
+      activeRequests = Math.max(0, activeRequests - 1);
+      if (activeRequests === 0) {
+        stopGlobalLoading();
       }
     }
     AxiosResponseIntrceptorErrorCallback(error);

package/lib/@ecme/services/axios/AxiosRequestIntrceptorConfigCallback.ts

@@ -1,47 +1,18 @@
-import appConfig from '@/configs/app.config'
-import {
-    TOKEN_TYPE,
-    REQUEST_HEADER_AUTH_KEY,
-    TOKEN_NAME_IN_STORAGE,
-} from '@/constants/api.constant'
+import { authHeaders } from '../aiAuthHeaders'
 import type { InternalAxiosRequestConfig } from 'axios'
 
+/**
+ * Injeta Authorization e X-User-Id em toda requisicao do Axios.
+ *
+ * As regras de onde o token mora vivem em `authHeaders` — compartilhadas com o
+ * chat de IA, que usa `fetch` e nao passa por aqui.
+ */
 const AxiosRequestIntrceptorConfigCallback = (
     config: InternalAxiosRequestConfig,
 ) => {
-    const storage = appConfig.accessTokenPersistStrategy
-
-    if (storage === 'localStorage' || storage === 'sessionStorage') {
-        let accessToken = ''
-
-        if (storage === 'localStorage') {
-            accessToken = localStorage.getItem(TOKEN_NAME_IN_STORAGE) || ''
-        }
-
-        if (storage === 'sessionStorage') {
-            accessToken = sessionStorage.getItem(TOKEN_NAME_IN_STORAGE) || ''
-        }
-
-        if (accessToken) {
-            config.headers[REQUEST_HEADER_AUTH_KEY] =
-                `${TOKEN_TYPE}${accessToken}`
-        }
-
-        // Adicionar X-User-Id header se o usuário estiver autenticado
-        try {
-            const sessionUserStore = localStorage.getItem('SessionUserPageStore')
-            if (sessionUserStore) {
-                const parsedStore = JSON.parse(sessionUserStore)
-                const userId = parsedStore?.state?.user?.userId
-                if (userId) {
-                    config.headers['X-User-Id'] = userId
-                }
-            }
-        } catch (error) {
-            // Silently ignore errors reading user session
-            console.debug('Could not read userId from session store:', error)
-        }
-    }
+    Object.entries(authHeaders()).forEach(([chave, valor]) => {
+        config.headers[chave] = valor
+    })
 
     return config
 }

package/lib/@ecme/services/sseParser.ts

@@ -0,0 +1,75 @@
+/**
+ * Parser de Server-Sent Events sobre um ReadableStream.
+ *
+ * O EventSource nativo do browser nao serve aqui: ele so faz GET e nao aceita
+ * headers, e o chat e um POST autenticado. Entao lemos o corpo do `fetch` na
+ * mao.
+ *
+ * Duas bordas do protocolo que uma implementacao ingenua erra:
+ *
+ * 1. um chunk da rede pode cortar um evento no meio — por isso o resto fica no
+ *    buffer ate chegar o proximo `\n\n`;
+ * 2. um chunk pode trazer varios eventos de uma vez.
+ */
+
+export type SseEvent = {
+    event: string
+    data: string
+}
+
+const SEPARADOR = /\r?\n\r?\n/
+
+/** Le o stream ate o fim, chamando `onEvent` a cada evento completo. */
+export async function readSse(
+    body: ReadableStream<Uint8Array>,
+    onEvent: (evento: SseEvent) => void,
+): Promise<void> {
+    const reader = body.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ''
+
+    try {
+        for (;;) {
+            const { done, value } = await reader.read()
+
+            if (done) {
+                // O ultimo evento pode nao vir seguido de linha em branco.
+                emitir(buffer, onEvent)
+                return
+            }
+
+            buffer += decoder.decode(value, { stream: true })
+
+            const blocos = buffer.split(SEPARADOR)
+            // O ultimo pedaco pode estar incompleto: volta para o buffer.
+            buffer = blocos.pop() ?? ''
+            blocos.forEach((bloco) => emitir(bloco, onEvent))
+        }
+    } finally {
+        reader.releaseLock()
+    }
+}
+
+/** Converte um bloco "event: x\ndata: y" em SseEvent. */
+function emitir(bloco: string, onEvent: (evento: SseEvent) => void) {
+    if (!bloco.trim()) {
+        return
+    }
+
+    let event = 'message'
+    const dados: string[] = []
+
+    bloco.split(/\r?\n/).forEach((linha) => {
+        if (linha.startsWith('event:')) {
+            event = linha.slice(6).trim()
+        } else if (linha.startsWith('data:')) {
+            // O espaco depois de "data:" e opcional no protocolo.
+            dados.push(linha.slice(5).replace(/^ /, ''))
+        }
+        // Linhas iniciadas por ":" sao comentarios (keep-alive) e sao ignoradas.
+    })
+
+    if (dados.length) {
+        onEvent({ event, data: dados.join('\n') })
+    }
+}

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

@@ -0,0 +1,28 @@
+import { TbPlugConnectedX } from 'react-icons/tb'
+
+/**
+ * Mensagem de erro do agente Orbe AI — exibida no lugar da resposta quando a
+ * comunicação com o serviço de IA falha, com acento vermelho para sinalizar
+ * o erro sem quebrar o tom visual do chat.
+ */
+const AiErrorMessage = () => {
+    return (
+        <span className="flex items-start gap-3">
+            <span className="mt-0.5 flex size-8 shrink-0 items-center justify-center rounded-full bg-red-100 text-red-500 dark:bg-red-500/15 dark:text-red-400">
+                <TbPlugConnectedX size={18} />
+            </span>
+            <span className="flex flex-col gap-0.5">
+                <span className="text-sm font-semibold text-red-600 dark:text-red-400">
+                    Falha na comunicação
+                </span>
+                <span className="text-sm text-red-500/90 dark:text-red-300/90">
+                    Desculpe, estou com um pequeno problema de comunicação e
+                    não consigo te atender no momento. Tente novamente em
+                    instantes.
+                </span>
+            </span>
+        </span>
+    )
+}
+
+export default AiErrorMessage

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

@@ -0,0 +1,24 @@
+import { TbSparkles } from 'react-icons/tb'
+
+/**
+ * Indicador de "pensando" do agente Orbe AI — loader profissional exibido
+ * enquanto a resposta está sendo gerada (estado isTyping do chat).
+ */
+const AiThinkingIndicator = () => {
+    return (
+        <span className="flex items-center gap-2 text-gray-500 dark:text-gray-400">
+            <TbSparkles
+                size={18}
+                className="text-primary motion-safe:animate-pulse"
+            />
+            <span className="text-sm">Orbe AI está pensando</span>
+            <span className="inline-flex items-center gap-1">
+                <span className="size-1.5 rounded-full bg-primary motion-safe:animate-bounce [animation-delay:-0.3s]" />
+                <span className="size-1.5 rounded-full bg-primary motion-safe:animate-bounce [animation-delay:-0.15s]" />
+                <span className="size-1.5 rounded-full bg-primary motion-safe:animate-bounce" />
+            </span>
+        </span>
+    )
+}
+
+export default AiThinkingIndicator