@orbe-agro/client-core 5.6.243 → 5.6.245

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

@@ -0,0 +1,144 @@
+import { useState } from 'react'
+import { TbForms } from 'react-icons/tb'
+import Button from '@/components/ui/Button'
+import Input from '@/components/ui/Input'
+import Select from '@/components/ui/Select'
+import { opcoesDoCampo, rotularCampo, tipoDoCampo } from './toolPresentation'
+import type { PendingInput } from '../types'
+
+type DataRequestCardProps = {
+    input: PendingInput
+    /** `null` = o usuario fechou sem preencher. */
+    onSubmit: (dados: Record<string, unknown> | null) => void
+}
+
+/**
+ * Formulario dos campos que faltam para criar um registro no ERP.
+ *
+ * O agente fica PARADO enquanto este card estiver na tela — ele so volta a
+ * responder depois do envio. Por isso divide o visual do ApprovalCard: sao as
+ * duas paradas do fluxo, e o usuario deve reconhece-las como a mesma coisa.
+ *
+ * Os valores vao para o modelo, que monta a chamada final. Por isso o envio nao
+ * valida tipo: o `type=number` e o select sao conveniencia de digitacao, nao
+ * regra de negocio — quem valida de verdade e o backend do ERP.
+ */
+const DataRequestCard = ({ input, onSubmit }: DataRequestCardProps) => {
+    const [valores, setValores] = useState<Record<string, string>>({})
+    const [enviando, setEnviando] = useState<'enviar' | 'cancelar' | null>(null)
+
+    const preencher = (campo: string, valor: string) =>
+        setValores((atual) => ({ ...atual, [campo]: valor }))
+
+    // Exigir todos evita uma ida e volta: faltando um, o agente pediria de novo.
+    const completo = input.campos.every((campo) => valores[campo]?.trim())
+
+    const enviar = () => {
+        setEnviando('enviar')
+        // Numeros vao como number; o resto como texto. O modelo aceita os dois,
+        // mas o tipo certo evita que ele precise adivinhar.
+        const dados = Object.fromEntries(
+            input.campos.map((campo) => {
+                const bruto = valores[campo].trim()
+                const numero =
+                    tipoDoCampo(campo) === 'numero' ? Number(bruto) : NaN
+                return [campo, Number.isNaN(numero) ? bruto : numero]
+            }),
+        )
+        onSubmit(dados)
+    }
+
+    const cancelar = () => {
+        setEnviando('cancelar')
+        onSubmit(null)
+    }
+
+    return (
+        <div className="not-prose mt-1 overflow-hidden rounded-xl border border-gray-200 bg-white shadow-sm dark:border-gray-700 dark:bg-gray-800">
+            <div className="flex items-center gap-2 border-b border-gray-200 px-4 py-2.5 dark:border-gray-700">
+                <TbForms size={16} className="text-gray-400 dark:text-gray-500" />
+                <span className="text-xs font-semibold uppercase tracking-wide text-gray-500 dark:text-gray-400">
+                    Dados necessários
+                </span>
+            </div>
+
+            <div className="px-4 py-3.5">
+                <div className="mb-3 text-sm text-gray-500 dark:text-gray-400">
+                    Preencha os campos abaixo para eu continuar.
+                </div>
+
+                <div className="flex flex-col gap-3">
+                    {input.campos.map((campo) => {
+                        const rotulo = rotularCampo(campo)
+                        const opcoes = opcoesDoCampo(campo)
+
+                        return (
+                            <label key={campo} className="flex flex-col gap-1">
+                                <span className="text-sm text-gray-600 dark:text-gray-300">
+                                    {rotulo}
+                                </span>
+                                {opcoes.length ? (
+                                    <Select
+                                        options={opcoes}
+                                        value={opcoes.filter(
+                                            (opcao) =>
+                                                opcao.value === valores[campo],
+                                        )}
+                                        placeholder={`Selecione ${rotulo.toLowerCase()}`}
+                                        isDisabled={enviando !== null}
+                                        onChange={(opcao) =>
+                                            preencher(
+                                                campo,
+                                                (opcao as { value: string } | null)
+                                                    ?.value ?? '',
+                                            )
+                                        }
+                                    />
+                                ) : (
+                                    <Input
+                                        type={
+                                            tipoDoCampo(campo) === 'numero'
+                                                ? 'number'
+                                                : 'text'
+                                        }
+                                        value={valores[campo] ?? ''}
+                                        disabled={enviando !== null}
+                                        placeholder={`Informe ${rotulo.toLowerCase()}`}
+                                        onChange={(evento) =>
+                                            preencher(campo, evento.target.value)
+                                        }
+                                    />
+                                )}
+                            </label>
+                        )
+                    })}
+                </div>
+
+                <div className="mt-4 flex items-center gap-2">
+                    <Button
+                        variant="solid"
+                        size="sm"
+                        loading={enviando === 'enviar'}
+                        disabled={!completo || enviando !== null}
+                        onClick={enviar}
+                    >
+                        Enviar
+                    </Button>
+                    <Button
+                        size="sm"
+                        loading={enviando === 'cancelar'}
+                        disabled={enviando !== null}
+                        onClick={cancelar}
+                    >
+                        Cancelar
+                    </Button>
+                    <span className="ml-auto text-xs text-gray-400 dark:text-gray-500">
+                        Você ainda confirma antes de gravar
+                    </span>
+                </div>
+            </div>
+        </div>
+    )
+}
+
+export default DataRequestCard

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

@@ -84,6 +84,35 @@ const REFERENCIAS = new Set([
 
 const ORDENACAO: Record<string, string> = { ASC: 'Crescente', DESC: 'Decrescente' }
 
+/**
+ * Opcoes dos campos que sao enum no backend.
+ *
+ * O rotulo sai do mesmo `humanizar` usado na exibicao, entao o formulario e o
+ * card de confirmacao mostram exatamente o mesmo texto.
+ */
+const OPCOES: Record<string, string[]> = {
+    tipo_contrato: ['MERCADO_INTERNO', 'MERCADO_EXTERNO'],
+}
+
+export const opcoesDoCampo = (chave: string) =>
+    (OPCOES[chave] ?? []).map((valor) => ({
+        value: valor,
+        label: humanizar(valor),
+    }))
+
+/**
+ * Que tipo de controle o campo pede no formulario de coleta.
+ *
+ * E so UX (teclado numerico, lista em vez de texto livre): os valores voltam
+ * para o modelo, e e ele quem monta a chamada final — um tipo errado nao
+ * quebra, so piora o preenchimento.
+ */
+export const tipoDoCampo = (chave: string): 'numero' | 'enum' | 'texto' => {
+    if (OPCOES[chave]) return 'enum'
+    if (REFERENCIAS.has(chave) || chave === 'saldo_negociado') return 'numero'
+    return 'texto'
+}
+
 /** Converte o valor tecnico no que o usuario espera ler. */
 export const formatarValor = (chave: string, valor: unknown): string => {
     if (valor === null || valor === undefined || valor === '') {

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

@@ -137,6 +137,15 @@ const useChatSend = () => {
                     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 traz a resposta final completa e é a fonte
                     // autoritativa — se algum token se perdeu, ele corrige.
@@ -235,9 +244,43 @@ const useChatSend = () => {
         )
     }
 
+    /**
+     * 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/types.ts

@@ -24,6 +24,17 @@ export type PendingApproval = {
     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: {
@@ -53,6 +64,8 @@ export type Conversation = {
     tools?: ToolCall[]
     /** Preenchido quando o agente pausou esperando aprovacao humana. */
     pendingApproval?: PendingApproval
+    /** Preenchido quando o agente pausou pedindo os dados que faltam. */
+    pendingInput?: PendingInput
 }
 
 /**
@@ -97,6 +110,16 @@ export type ChatEvent =
               }[]
           }
       }
+    | {
+          /**
+           * 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 } }
 

package/lib/base/@types/models/racao/carga.ts

@@ -63,6 +63,7 @@ export type TOrdensCarga = {
 }
 
 export type TProdutosOrdemCarga = {
+    id?: number
     produtoId: number
     codigo: string
     descricao: string

package/lib/base/configs/endpoints.config/agendamento/config/contratoVenda.ts

@@ -1,7 +1,6 @@
 const contratoVenda = {
   findAll: '/agendamento/api/contrato-venda',
   findOne: '/agendamento/api/contrato-venda',
-  findContratos: '/agendamento/api/vendas/contrato/find',
   comSaldoByCliente: '/agendamento/api/contrato-venda/com-saldo/cliente',
   relatorioCotas: '/agendamento/api/contrato-venda/find-relatorio-cotas',
   periodo: '/agendamento/api/contrato-venda/periodo',

package/lib/base/configs/endpoints.config/dm/config/municipio.ts

@@ -5,7 +5,8 @@ const municipio = {
     findMunicipioByCodigo: { endpoint: `${MUNICIPIO_BASE_URL}/find/`, method: 'post' },
     findMonitor: { endpoint: `${MUNICIPIO_BASE_URL}/find-monitor`, httpMethod: 'post' },
     findAllUfs: { endpoint: `${MUNICIPIO_BASE_URL}/find-all-ufs`, httpMethod: 'get' },
-    findMunicipioByUf: { endpoint: `${MUNICIPIO_BASE_URL}/find-municipio-by-uf/`, httpMethod: 'get' }
+    findMunicipioByUf: { endpoint: `${MUNICIPIO_BASE_URL}/find-municipio-by-uf/`, httpMethod: 'get' },
+    findById : { endpoint: `${MUNICIPIO_BASE_URL}`, httpMethod: 'get' }
 }
 
 export default municipio

package/lib/base/services/modules/agendamento/ContratoVendaService.ts

@@ -36,7 +36,7 @@ export async function apiFindContratosComSaldoPorCliente(clienteId: string | num
 
 export async function apiFindAllContratos(params: Record<string, unknown>) {
   return ApiService.fetchDataWithAxios<TQueryResponse<TContratoVenda>>({
-    url: endpointsConfig.agendamento.contratoVenda.findContratos,
+    url: endpointsConfig.agendamento.contratoVenda.findAll,
     method: 'post',
     data: params,
   })
@@ -44,7 +44,7 @@ export async function apiFindAllContratos(params: Record<string, unknown>) {
 
 export async function apiFindACDVendasContrato(contratoNumero: string) {
   return ApiService.fetchDataWithAxios<TQueryResponse<TContratoVenda>>({
-    url: endpointsConfig.agendamento.contratoVenda.findContratos,
+    url: endpointsConfig.agendamento.contratoVenda.findAll,
     method: 'post',
     data: {
       pageNumber: 1,

package/lib/base/services/modules/dm/municipio/MunicipioService.tsx

@@ -41,3 +41,10 @@ export async function apiFindMunicipioByUf(uf: string) {
         method: MUNICIPIO_ENDPOINT.findMunicipioByUf.httpMethod,
     })
 }
+
+export async function apiFindMunicipioById(id: string) {
+    return ApiService.fetchDataWithAxios<TMunicipio>({
+        url: MUNICIPIO_ENDPOINT.findById.endpoint + `/${id}`,
+        method: MUNICIPIO_ENDPOINT.findById.httpMethod,
+    })
+}

package/package.json

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