@orbe-agro/client-core 5.6.238 → 5.6.240

package/lib/@ecme/views/concepts/ai/Chat/components/toolPresentation.ts

@@ -0,0 +1,137 @@
+import { formatQuantity } from '@base/utils/functions/stringUtils'
+import { TbFilePlus, TbListSearch, TbSearch, TbTool } from 'react-icons/tb'
+import type { IconType } from 'react-icons'
+
+/**
+ * Como as ferramentas do agente sao apresentadas ao usuario.
+ *
+ * Compartilhado pelo chip de execucao e pelo card de aprovacao, para os dois
+ * falarem a mesma lingua: o usuario ve "Consulta de contratos" e "Mercado
+ * interno", nunca `listar_contratos_armazenagem_graos` ou `MERCADO_INTERNO`.
+ *
+ * Tudo tem fallback: uma ferramenta ou campo novo no backend nao quebra a tela,
+ * so aparece com o nome tecnico humanizado ate ganhar entrada aqui.
+ */
+
+type Ferramenta = {
+    rotulo: string
+    /** Frase no gerundio, para o estado "executando". */
+    executando: string
+    icone: IconType
+}
+
+const FERRAMENTAS: Record<string, Ferramenta> = {
+    buscar_contrato_armazenagem_graos: {
+        rotulo: 'Consulta de contrato',
+        executando: 'Consultando contrato',
+        icone: TbSearch,
+    },
+    listar_contratos_armazenagem_graos: {
+        rotulo: 'Consulta de contratos',
+        executando: 'Consultando contratos',
+        icone: TbListSearch,
+    },
+    criar_contrato_armazenagem_graos: {
+        rotulo: 'Criação de contrato de armazenagem',
+        executando: 'Criando contrato',
+        icone: TbFilePlus,
+    },
+}
+
+const humanizar = (texto: string) =>
+    texto
+        .replaceAll('_', ' ')
+        .toLowerCase()
+        .replace(/^./, (letra) => letra.toUpperCase())
+
+export const rotularFerramenta = (nome: string) =>
+    FERRAMENTAS[nome]?.rotulo ?? humanizar(nome)
+
+export const rotularExecucao = (nome: string) =>
+    FERRAMENTAS[nome]?.executando ?? humanizar(nome)
+
+export const iconeFerramenta = (nome: string): IconType =>
+    FERRAMENTAS[nome]?.icone ?? TbTool
+
+/** Rotulos dos parametros, na linguagem do negocio. */
+const CAMPOS: Record<string, string> = {
+    business_partner_id: 'Parceiro de negócio',
+    produto_id: 'Produto',
+    safra_id: 'Safra',
+    saldo_negociado: 'Saldo negociado',
+    tipo_contrato: 'Tipo de contrato',
+    contrato_venda: 'Contrato de venda',
+    ordem_venda: 'Ordem de venda',
+    id: 'Contrato',
+    page_number: 'Página',
+    page_size: 'Itens por página',
+    sort_field: 'Ordenar por',
+    sort_order: 'Ordem',
+    filtro: 'Filtro',
+}
+
+export const rotularCampo = (chave: string) => CAMPOS[chave] ?? humanizar(chave)
+
+/** Campos que sao referencia a um registro: exibidos como "#123". */
+const REFERENCIAS = new Set([
+    'business_partner_id',
+    'produto_id',
+    'safra_id',
+    'contrato_venda',
+    'ordem_venda',
+    'id',
+])
+
+const ORDENACAO: Record<string, string> = { ASC: 'Crescente', DESC: 'Decrescente' }
+
+/** Converte o valor tecnico no que o usuario espera ler. */
+export const formatarValor = (chave: string, valor: unknown): string => {
+    if (valor === null || valor === undefined || valor === '') {
+        return '—'
+    }
+    if (chave === 'saldo_negociado' && typeof valor === 'number') {
+        return formatQuantity(valor)
+    }
+    if (chave === 'sort_order' && typeof valor === 'string') {
+        return ORDENACAO[valor] ?? humanizar(valor)
+    }
+    if (typeof valor === 'number') {
+        return REFERENCIAS.has(chave) ? `#${valor}` : String(valor)
+    }
+    if (typeof valor === 'boolean') {
+        return valor ? 'Sim' : 'Não'
+    }
+    if (typeof valor === 'string') {
+        // Enums do backend chegam em CAIXA_ALTA_COM_UNDERSCORE.
+        return /^[A-Z][A-Z0-9_]+$/.test(valor) ? humanizar(valor) : valor
+    }
+    if (Array.isArray(valor)) {
+        return valor.length ? `${valor.length} item(ns)` : '—'
+    }
+    if (typeof valor === 'object') {
+        const entradas = Object.entries(valor as Record<string, unknown>)
+        if (!entradas.length) {
+            return '—'
+        }
+        return entradas
+            .map(([k, v]) => `${rotularCampo(k)}: ${formatarValor(k, v)}`)
+            .join(', ')
+    }
+    return String(valor)
+}
+
+/** Pares (rotulo, valor) prontos para exibir, ignorando o que esta vazio. */
+export const camposVisiveis = (args: Record<string, unknown>) =>
+    Object.entries(args)
+        .filter(([, valor]) => {
+            if (valor === null || valor === undefined || valor === '') return false
+            if (typeof valor === 'object' && !Array.isArray(valor)) {
+                return Object.keys(valor as object).length > 0
+            }
+            return true
+        })
+        .map(([chave, valor]) => ({
+            chave,
+            rotulo: rotularCampo(chave),
+            valor: formatarValor(chave, valor),
+        }))

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/lib/base/configs/endpoints.config/HubFiscal/nfe.endpoint.config.ts

@@ -5,7 +5,7 @@ const nfeEndpointConfig = {
     getPdf: `${NFE_API_PATH}/pdf/`,
     addObservacao: `${NFE_API_PATH}/observacao`,
     findEventos: `${NFE_API_PATH}/eventos/`,  
-    addCartaCorrecao: `${NFE_API_PATH}/carta-correcao`,
+    addEvento: `${NFE_API_PATH}/evento`,
     montaRelatorioNfeRecebidas: `${NFE_API_PATH}/relatorio-nfe-recebidas/`,
     downloadRelatorioNfeRecebidas: (fileName) => `${NFE_API_PATH}/relatorio-nfe-recebidas/${fileName}/download`,
 }

package/lib/base/services/modules/HubFiscal/NfeService.ts

@@ -31,9 +31,9 @@ export async function apiGetEventosNfe(chaveAcesso) {
     })
 }
 
-export async function apiAddCartaCorrecao(body) {
+export async function apiAddEvento(body) {
     return ApiService.fetchDataWithAxios({
-        url: nfeEndpointConfig.addCartaCorrecao,
+        url: nfeEndpointConfig.addEvento,
         method: 'post',
         data: body,
     })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orbe-agro/client-core",
-  "version": "5.6.238",
+  "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;"}