@orbe-agro/client-core 5.6.239 → 5.6.240

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

@@ -1,9 +1,13 @@
 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 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()
@@ -12,6 +16,7 @@ const useChatSend = () => {
         setSelectedConversation,
         pushChatHistory,
         pushConversation,
+        updateConversation,
         setIsTyping,
     } = usGenerativeChatStore()
 
@@ -30,41 +35,153 @@ 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 'done':
+                    // O done traz a resposta final completa e é a fonte
+                    // autoritativa — se algum token se perdeu, ele corrige.
+                    updateConversation(chatId, messageId, {
+                        content: evento.data.content,
+                    })
+                    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)
@@ -80,12 +197,47 @@ const useChatSend = () => {
                 enable: false,
             })
             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 ?? [] },
+        )
+    }
+
     return {
         handleSend,
+        handleApproval,
     }
 }
 

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

@@ -24,6 +24,11 @@ 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
 }
 
@@ -70,20 +75,43 @@ export const usGenerativeChatStore = create<
             return { selectedConversationRecord: record }
         }),
     pushChatHistory: (payload) =>
-        set(() => ({ chatHistory: [...[payload], ...get().chatHistory] })),
+        set(() => ({ chatHistory: [payload, ...get().chatHistory] })),
     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(() => {

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

@@ -1,3 +1,29 @@
+/** 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> }[]
+}
+
 export type Conversation = {
     id: string
     sender: {
@@ -14,38 +40,65 @@ 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
 }
 
-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
-}
+/**
+ * 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>
+              }[]
+          }
+      }
+    | { type: 'done'; data: { content: string } }
+    | { type: 'error'; data: { message: string } }
 
 export type ChatHistory = {
     id: string

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbe-agro/client-core",
-  "version": "5.6.239",
+  "version": "5.6.240",
   "description": "Biblioteca principal de componentes e utilidades para os microfrontends do Orbe Agro.",
   "type": "module",
   "main": "./dist/index.js",

package/dist/@ecme/views/concepts/ai/Chat/components/ModelSelect.js

@@ -1,48 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { useState, useEffect } from "react";
-import { apiGetAiModels } from "../../../../../services/AiService.js";
-import { useAiModelStore } from "../store/aiModelStore.js";
-const ModelSelect = () => {
-  const [models, setModels] = useState([]);
-  const selectedModel = useAiModelStore((state) => state.selectedModel);
-  const setSelectedModel = useAiModelStore((state) => state.setSelectedModel);
-  useEffect(() => {
-    let active = true;
-    apiGetAiModels().then((resp) => {
-      if (!active) {
-        return;
-      }
-      setModels(resp.models);
-      const current = useAiModelStore.getState().selectedModel;
-      const exists = resp.models.some((model) => model.id === current);
-      if (!current || !exists) {
-        const fallback = resp.models.find((model) => model.default) ?? resp.models[0];
-        if (fallback) {
-          useAiModelStore.getState().setSelectedModel(fallback.id);
-        }
-      }
-    }).catch(() => {
-    });
-    return () => {
-      active = false;
-    };
-  }, []);
-  if (models.length === 0) {
-    return null;
-  }
-  return /* @__PURE__ */ jsx(
-    "select",
-    {
-      "aria-label": "Modelo de IA",
-      title: "Modelo de IA",
-      className: "max-w-[9rem] truncate rounded-lg border border-gray-300 bg-white px-2 py-1 text-xs dark:border-gray-600 dark:bg-gray-800",
-      value: selectedModel ?? "",
-      onChange: (event) => setSelectedModel(event.target.value),
-      children: models.map((model) => /* @__PURE__ */ jsx("option", { value: model.id, children: model.label }, model.id))
-    }
-  );
-};
-export {
-  ModelSelect as default
-};
-//# sourceMappingURL=ModelSelect.js.map

package/dist/@ecme/views/concepts/ai/Chat/components/ModelSelect.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ModelSelect.js","sources":["../../../../../../../lib/@ecme/views/concepts/ai/Chat/components/ModelSelect.tsx"],"sourcesContent":["import { useEffect, useState } from 'react'\nimport { apiGetAiModels } from '@/services/AiService'\nimport { useAiModelStore } from '../store/aiModelStore'\nimport type { AiModel, GetAiModelsResponse } from '@/services/AiService'\n\n/**\n * Seletor do modelo de IA do chat (GET /ai/models). Se o backend estiver\n * indisponivel ou nao expuser modelos, o seletor nao aparece e o backend usa o\n * modelo default — por isso ele pode ser montado sem medo em qualquer MFE.\n */\nconst ModelSelect = () => {\n    const [models, setModels] = useState<AiModel[]>([])\n    const selectedModel = useAiModelStore((state) => state.selectedModel)\n    const setSelectedModel = useAiModelStore((state) => state.setSelectedModel)\n\n    useEffect(() => {\n        let active = true\n        apiGetAiModels<GetAiModelsResponse>()\n            .then((resp) => {\n                if (!active) {\n                    return\n                }\n                setModels(resp.models)\n                const current = useAiModelStore.getState().selectedModel\n                const exists = resp.models.some((model) => model.id === current)\n                if (!current || !exists) {\n                    const fallback =\n                        resp.models.find((model) => model.default) ??\n                        resp.models[0]\n                    if (fallback) {\n                        useAiModelStore\n                            .getState()\n                            .setSelectedModel(fallback.id)\n                    }\n                }\n            })\n            .catch(() => {\n                // Sem lista de modelos: o backend responde com o default.\n            })\n        return () => {\n            active = false\n        }\n    }, [])\n\n    if (models.length === 0) {\n        return null\n    }\n\n    return (\n        <select\n            aria-label=\"Modelo de IA\"\n            title=\"Modelo de IA\"\n            className=\"max-w-[9rem] truncate rounded-lg border border-gray-300 bg-white px-2 py-1 text-xs dark:border-gray-600 dark:bg-gray-800\"\n            value={selectedModel ?? ''}\n            onChange={(event) => setSelectedModel(event.target.value)}\n        >\n            {models.map((model) => (\n                <option key={model.id} value={model.id}>\n                    {model.label}\n                </option>\n            ))}\n        </select>\n    )\n}\n\nexport default ModelSelect\n"],"names":[],"mappings":";;;;AAUA,MAAM,cAAc,MAAM;AACtB,QAAM,CAAC,QAAQ,SAAS,IAAI,SAAoB,CAAA,CAAE;AAClD,QAAM,gBAAgB,gBAAgB,CAAC,UAAU,MAAM,aAAa;AACpE,QAAM,mBAAmB,gBAAgB,CAAC,UAAU,MAAM,gBAAgB;AAE1E,YAAU,MAAM;AACZ,QAAI,SAAS;AACb,mBAAA,EACK,KAAK,CAAC,SAAS;AACZ,UAAI,CAAC,QAAQ;AACT;AAAA,MACJ;AACA,gBAAU,KAAK,MAAM;AACrB,YAAM,UAAU,gBAAgB,SAAA,EAAW;AAC3C,YAAM,SAAS,KAAK,OAAO,KAAK,CAAC,UAAU,MAAM,OAAO,OAAO;AAC/D,UAAI,CAAC,WAAW,CAAC,QAAQ;AACrB,cAAM,WACF,KAAK,OAAO,KAAK,CAAC,UAAU,MAAM,OAAO,KACzC,KAAK,OAAO,CAAC;AACjB,YAAI,UAAU;AACV,0BACK,SAAA,EACA,iBAAiB,SAAS,EAAE;AAAA,QACrC;AAAA,MACJ;AAAA,IACJ,CAAC,EACA,MAAM,MAAM;AAAA,IAEb,CAAC;AACL,WAAO,MAAM;AACT,eAAS;AAAA,IACb;AAAA,EACJ,GAAG,CAAA,CAAE;AAEL,MAAI,OAAO,WAAW,GAAG;AACrB,WAAO;AAAA,EACX;AAEA,SACI;AAAA,IAAC;AAAA,IAAA;AAAA,MACG,cAAW;AAAA,MACX,OAAM;AAAA,MACN,WAAU;AAAA,MACV,OAAO,iBAAiB;AAAA,MACxB,UAAU,CAAC,UAAU,iBAAiB,MAAM,OAAO,KAAK;AAAA,MAEvD,UAAA,OAAO,IAAI,CAAC,UACT,oBAAC,UAAA,EAAsB,OAAO,MAAM,IAC/B,UAAA,MAAM,MAAA,GADE,MAAM,EAEnB,CACH;AAAA,IAAA;AAAA,EAAA;AAGb;"}

package/dist/@ecme/views/concepts/ai/Chat/store/aiModelStore.js

@@ -1,15 +0,0 @@
-import { create } from "zustand";
-import { persist } from "zustand/middleware";
-const useAiModelStore = create()(
-  persist(
-    (set) => ({
-      selectedModel: null,
-      setSelectedModel: (model) => set({ selectedModel: model })
-    }),
-    { name: "orbe-ai-model" }
-  )
-);
-export {
-  useAiModelStore
-};
-//# sourceMappingURL=aiModelStore.js.map

package/dist/@ecme/views/concepts/ai/Chat/store/aiModelStore.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"aiModelStore.js","sources":["../../../../../../../lib/@ecme/views/concepts/ai/Chat/store/aiModelStore.ts"],"sourcesContent":["import { create } from 'zustand'\nimport { persist } from 'zustand/middleware'\n\ntype AiModelState = {\n    selectedModel: string | null\n    setSelectedModel: (model: string) => void\n}\n\n/**\n * Modelo de IA escolhido pelo usuario para o chat do Orbe AI.\n *\n * Persistido em localStorage: como todos os MFEs vivem na mesma origem, a\n * escolha acompanha o usuario entre os modulos e entre sessoes.\n */\nexport const useAiModelStore = create<AiModelState>()(\n    persist(\n        (set) => ({\n            selectedModel: null,\n            setSelectedModel: (model) => set({ selectedModel: model }),\n        }),\n        { name: 'orbe-ai-model' },\n    ),\n)\n"],"names":[],"mappings":";;AAcO,MAAM,kBAAkB,OAAA;AAAA,EAC3B;AAAA,IACI,CAAC,SAAS;AAAA,MACN,eAAe;AAAA,MACf,kBAAkB,CAAC,UAAU,IAAI,EAAE,eAAe,OAAO;AAAA,IAAA;AAAA,IAE7D,EAAE,MAAM,gBAAA;AAAA,EAAgB;AAEhC;"}

package/dist/@types/@ecme/views/concepts/ai/Chat/components/ModelSelect.d.ts

@@ -1,8 +0,0 @@
-/**
- * Seletor do modelo de IA do chat (GET /ai/models). Se o backend estiver
- * indisponivel ou nao expuser modelos, o seletor nao aparece e o backend usa o
- * modelo default — por isso ele pode ser montado sem medo em qualquer MFE.
- */
-declare const ModelSelect: () => import("react/jsx-runtime").JSX.Element | null;
-export default ModelSelect;
-//# sourceMappingURL=ModelSelect.d.ts.map

package/dist/@types/@ecme/views/concepts/ai/Chat/components/ModelSelect.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ModelSelect.d.ts","sourceRoot":"","sources":["../../../../../../../../lib/@ecme/views/concepts/ai/Chat/components/ModelSelect.tsx"],"names":[],"mappings":"AAKA;;;;GAIG;AACH,QAAA,MAAM,WAAW,sDAqDhB,CAAA;AAED,eAAe,WAAW,CAAA"}

package/dist/@types/@ecme/views/concepts/ai/Chat/store/aiModelStore.d.ts

@@ -1,25 +0,0 @@
-type AiModelState = {
-    selectedModel: string | null;
-    setSelectedModel: (model: string) => void;
-};
-/**
- * Modelo de IA escolhido pelo usuario para o chat do Orbe AI.
- *
- * Persistido em localStorage: como todos os MFEs vivem na mesma origem, a
- * escolha acompanha o usuario entre os modulos e entre sessoes.
- */
-export declare const useAiModelStore: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<AiModelState>, "setState" | "persist"> & {
-    setState(partial: AiModelState | Partial<AiModelState> | ((state: AiModelState) => AiModelState | Partial<AiModelState>), replace?: false | undefined): unknown;
-    setState(state: AiModelState | ((state: AiModelState) => AiModelState), replace: true): unknown;
-    persist: {
-        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<AiModelState, AiModelState, unknown>>) => void;
-        clearStorage: () => void;
-        rehydrate: () => Promise<void> | void;
-        hasHydrated: () => boolean;
-        onHydrate: (fn: (state: AiModelState) => void) => () => void;
-        onFinishHydration: (fn: (state: AiModelState) => void) => () => void;
-        getOptions: () => Partial<import("zustand/middleware").PersistOptions<AiModelState, AiModelState, unknown>>;
-    };
-}>;
-export {};
-//# sourceMappingURL=aiModelStore.d.ts.map

package/dist/@types/@ecme/views/concepts/ai/Chat/store/aiModelStore.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"aiModelStore.d.ts","sourceRoot":"","sources":["../../../../../../../../lib/@ecme/views/concepts/ai/Chat/store/aiModelStore.ts"],"names":[],"mappings":"AAGA,KAAK,YAAY,GAAG;IAChB,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,gBAAgB,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;CAC5C,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;EAQ3B,CAAA"}

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

@@ -1,66 +0,0 @@
-import { useEffect, useState } from 'react'
-import { apiGetAiModels } from '@/services/AiService'
-import { useAiModelStore } from '../store/aiModelStore'
-import type { AiModel, GetAiModelsResponse } from '@/services/AiService'
-
-/**
- * Seletor do modelo de IA do chat (GET /ai/models). Se o backend estiver
- * indisponivel ou nao expuser modelos, o seletor nao aparece e o backend usa o
- * modelo default — por isso ele pode ser montado sem medo em qualquer MFE.
- */
-const ModelSelect = () => {
-    const [models, setModels] = useState<AiModel[]>([])
-    const selectedModel = useAiModelStore((state) => state.selectedModel)
-    const setSelectedModel = useAiModelStore((state) => state.setSelectedModel)
-
-    useEffect(() => {
-        let active = true
-        apiGetAiModels<GetAiModelsResponse>()
-            .then((resp) => {
-                if (!active) {
-                    return
-                }
-                setModels(resp.models)
-                const current = useAiModelStore.getState().selectedModel
-                const exists = resp.models.some((model) => model.id === current)
-                if (!current || !exists) {
-                    const fallback =
-                        resp.models.find((model) => model.default) ??
-                        resp.models[0]
-                    if (fallback) {
-                        useAiModelStore
-                            .getState()
-                            .setSelectedModel(fallback.id)
-                    }
-                }
-            })
-            .catch(() => {
-                // Sem lista de modelos: o backend responde com o default.
-            })
-        return () => {
-            active = false
-        }
-    }, [])
-
-    if (models.length === 0) {
-        return null
-    }
-
-    return (
-        <select
-            aria-label="Modelo de IA"
-            title="Modelo de IA"
-            className="max-w-[9rem] truncate rounded-lg border border-gray-300 bg-white px-2 py-1 text-xs dark:border-gray-600 dark:bg-gray-800"
-            value={selectedModel ?? ''}
-            onChange={(event) => setSelectedModel(event.target.value)}
-        >
-            {models.map((model) => (
-                <option key={model.id} value={model.id}>
-                    {model.label}
-                </option>
-            ))}
-        </select>
-    )
-}
-
-export default ModelSelect

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

@@ -1,23 +0,0 @@
-import { create } from 'zustand'
-import { persist } from 'zustand/middleware'
-
-type AiModelState = {
-    selectedModel: string | null
-    setSelectedModel: (model: string) => void
-}
-
-/**
- * Modelo de IA escolhido pelo usuario para o chat do Orbe AI.
- *
- * Persistido em localStorage: como todos os MFEs vivem na mesma origem, a
- * escolha acompanha o usuario entre os modulos e entre sessoes.
- */
-export const useAiModelStore = create<AiModelState>()(
-    persist(
-        (set) => ({
-            selectedModel: null,
-            setSelectedModel: (model) => set({ selectedModel: model }),
-        }),
-        { name: 'orbe-ai-model' },
-    ),
-)