@meistrari/chat-nuxt 1.13.0 → 2.0.0

package/dist/runtime/messages/composables/chat.js

@@ -0,0 +1,383 @@
+import { useChatAuth } from "#chat-auth";
+import * as Sentry from "@sentry/nuxt";
+import {
+  createReasoningCache,
+  resolveReasoningDisplayMessages
+} from "../message-reasoning.js";
+import {
+  beginAssistantMessageRetry,
+  markPendingAssistantMessagesInterrupted,
+  restoreAssistantMessageAfterRetryFailure,
+  selectTitleGenerationMessages,
+  shouldTreatLoadedConversationTitleAsGenerated
+} from "../message-state.js";
+import { exportConversationToMarkdown } from "../../conversations/export.js";
+import { resolveChatStateScope } from "../../conversations/scope.js";
+import { useChatApi } from "../../shared/composables/chat-api.js";
+import { useConversationFileActions } from "../../files/composables/conversation-files.js";
+import { useEmbedConfig } from "../../embed/composables/embed-config.js";
+import { usePolling } from "../../shared/composables/polling.js";
+function resolveTelaAgentInputs(messageInputs, configuredInputs) {
+  const inputs = messageInputs ?? configuredInputs ?? void 0;
+  return inputs?.length ? inputs.map((input) => ({ ...input })) : void 0;
+}
+export function useChat() {
+  const chatApi = useChatApi();
+  const embedConfig = useEmbedConfig();
+  const { user: authUser, activeOrganization } = useChatAuth();
+  const { addFilesToConversation } = useConversationFileActions();
+  const isTelaAgentMode = computed(() => !!embedConfig?.telaAgentId.value);
+  const chatScope = computed(() => resolveChatStateScope(
+    embedConfig?.workspaceId.value || activeOrganization.value?.id,
+    embedConfig?.telaAgentId.value,
+    embedConfig?.conversationScope?.value
+  ));
+  const currentConversationBuckets = useState("chat-current-conversation", () => ({}));
+  const messageBuckets = useState("chat-messages", () => ({}));
+  const currentConversation = computed({
+    get: () => currentConversationBuckets.value[chatScope.value] ?? null,
+    set: (value) => {
+      currentConversationBuckets.value = {
+        ...currentConversationBuckets.value,
+        [chatScope.value]: value
+      };
+    }
+  });
+  const messages = computed({
+    get: () => messageBuckets.value[chatScope.value] ?? [],
+    set: (value) => {
+      messageBuckets.value = {
+        ...messageBuckets.value,
+        [chatScope.value]: value
+      };
+    }
+  });
+  const loading = ref(false);
+  const sending = ref(false);
+  const error = ref(null);
+  const titleGenerated = ref(false);
+  const generatingTitle = ref(false);
+  const animatedTitle = ref(null);
+  const hasPendingMessage = computed(
+    () => messages.value.some((m) => m.status === "pending")
+  );
+  const reasoningCache = createReasoningCache();
+  const processedMessages = computed(() => resolveReasoningDisplayMessages(messages.value, reasoningCache));
+  const stopCondition = computed(() => !hasPendingMessage.value);
+  const pollMessages = async () => {
+    if (!currentConversation.value)
+      return;
+    try {
+      const response = await $fetch(
+        chatApi.path(`/conversations/${currentConversation.value.id}/messages`),
+        chatApi.withChatHeaders()
+      );
+      messages.value = response.messages;
+      if (response.newFiles && response.newFiles.length > 0) {
+        const lastAssistantMessage = response.messages.findLast((m) => m.role === "assistant");
+        if (lastAssistantMessage) {
+          addFilesToConversation(
+            currentConversation.value.id,
+            response.newFiles,
+            lastAssistantMessage.id,
+            "assistant"
+          );
+        }
+      }
+    } catch (err) {
+      Sentry.captureException(err);
+    }
+  };
+  const { isPolling, start: startPolling, stop: stopPolling } = usePolling({
+    callback: pollMessages,
+    interval: 500,
+    stopCondition
+  });
+  const setConversation = (conv) => {
+    const conversationMessages = "messages" in conv ? conv.messages : [];
+    currentConversation.value = { ...conv, messages: conversationMessages };
+    messages.value = conversationMessages;
+    titleGenerated.value = false;
+    error.value = null;
+  };
+  const loadConversation = async (id) => {
+    loading.value = true;
+    error.value = null;
+    titleGenerated.value = false;
+    try {
+      const data = await $fetch(
+        chatApi.path(`/conversations/${id}`),
+        chatApi.withChatHeaders()
+      );
+      currentConversation.value = data;
+      messages.value = data.messages;
+      if (shouldTreatLoadedConversationTitleAsGenerated(data.messages)) {
+        titleGenerated.value = true;
+      }
+      if (data.messages.some((m) => m.status === "pending")) {
+        startPolling();
+      }
+    } catch (err) {
+      currentConversation.value = null;
+      messages.value = [];
+      const message = err instanceof Error ? err.message : "Erro ao carregar conversa";
+      error.value = message;
+      Sentry.captureException(err);
+    } finally {
+      loading.value = false;
+    }
+  };
+  const sendMessage = async (content, files, model, agentInputs) => {
+    if (!currentConversation.value)
+      return null;
+    sending.value = true;
+    error.value = null;
+    const filesWithSource = files?.map((f) => ({ ...f, source: "user" })) ?? null;
+    const optimisticUserMessage = {
+      id: crypto.randomUUID(),
+      conversationId: currentConversation.value.id,
+      role: "user",
+      content,
+      status: "completed",
+      reasoningData: null,
+      files: filesWithSource,
+      externalUuid: null,
+      ttft: null,
+      createdBy: authUser.value?.email ?? null,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: null
+    };
+    const optimisticAssistantMessage = {
+      id: crypto.randomUUID(),
+      conversationId: currentConversation.value.id,
+      role: "assistant",
+      content: "",
+      status: "pending",
+      reasoningData: null,
+      files: null,
+      externalUuid: null,
+      ttft: null,
+      createdBy: null,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: null
+    };
+    messages.value = [...messages.value, optimisticUserMessage, optimisticAssistantMessage];
+    try {
+      const workspaceSettingsSnapshot = embedConfig?.workspaceSettings.value;
+      const resolvedAgentInputs = resolveTelaAgentInputs(agentInputs, embedConfig?.telaAgentInputs?.value);
+      const body = {
+        content,
+        files,
+        ...isTelaAgentMode.value ? {
+          ...resolvedAgentInputs ? { agentInputs: resolvedAgentInputs } : {}
+        } : {
+          model,
+          ...workspaceSettingsSnapshot !== void 0 ? { workspaceSettingsSnapshot } : {}
+        }
+      };
+      const response = await $fetch(
+        chatApi.path(`/conversations/${currentConversation.value.id}/messages`),
+        chatApi.withChatHeaders({
+          method: "POST",
+          body
+        })
+      );
+      messages.value = messages.value.map((msg) => {
+        if (msg.id === optimisticUserMessage.id)
+          return response.userMessage;
+        if (msg.id === optimisticAssistantMessage.id)
+          return response.assistantMessage;
+        return msg;
+      });
+      if (files && files.length > 0) {
+        addFilesToConversation(
+          currentConversation.value.id,
+          files.map((f) => ({ ...f, source: "user" })),
+          response.userMessage.id,
+          "user"
+        );
+      }
+      startPolling();
+      return response.userMessage;
+    } catch (err) {
+      messages.value = messages.value.filter(
+        (msg) => msg.id !== optimisticUserMessage.id && msg.id !== optimisticAssistantMessage.id
+      );
+      stopPolling();
+      const message = err instanceof Error ? err.message : "Erro ao enviar mensagem";
+      error.value = message;
+      Sentry.captureException(err);
+      return null;
+    } finally {
+      sending.value = false;
+    }
+  };
+  const clearConversation = () => {
+    stopPolling();
+    currentConversation.value = null;
+    messages.value = [];
+    error.value = null;
+  };
+  const cancelling = ref(false);
+  const cancelConversation = async () => {
+    if (!currentConversation.value || !hasPendingMessage.value)
+      return false;
+    cancelling.value = true;
+    error.value = null;
+    try {
+      await $fetch(
+        chatApi.path(`/conversations/${currentConversation.value.id}/cancel`),
+        chatApi.withChatHeaders({ method: "POST" })
+      );
+      messages.value = markPendingAssistantMessagesInterrupted(messages.value);
+      stopPolling();
+      return true;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Erro ao cancelar conversa";
+      error.value = message;
+      Sentry.captureException(err);
+      return false;
+    } finally {
+      cancelling.value = false;
+    }
+  };
+  const clearConversationThread = async () => {
+    if (!currentConversation.value)
+      return false;
+    error.value = null;
+    try {
+      const updated = await $fetch(
+        chatApi.path(`/conversations/${currentConversation.value.id}/clear`),
+        chatApi.withChatHeaders({ method: "POST" })
+      );
+      currentConversation.value = {
+        ...currentConversation.value,
+        ...updated,
+        messages: []
+      };
+      messages.value = [];
+      return true;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Erro ao limpar conversa";
+      error.value = message;
+      Sentry.captureException(err);
+      return false;
+    }
+  };
+  const retryMessage = async (messageId) => {
+    if (!currentConversation.value)
+      return false;
+    error.value = null;
+    const retry = beginAssistantMessageRetry(messages.value, messageId);
+    if (!retry)
+      return false;
+    messages.value = retry.messages;
+    try {
+      await $fetch(
+        chatApi.path(`/conversations/${currentConversation.value.id}/messages/${messageId}/retry`),
+        chatApi.withChatHeaders({ method: "POST" })
+      );
+      startPolling();
+      return true;
+    } catch (err) {
+      messages.value = restoreAssistantMessageAfterRetryFailure(messages.value, retry.originalMessage);
+      const errorMessage = err instanceof Error ? err.message : "Erro ao reenviar mensagem";
+      error.value = errorMessage;
+      Sentry.captureException(err);
+      return false;
+    }
+  };
+  const animateTitle = (title) => {
+    return new Promise((resolve) => {
+      animatedTitle.value = "";
+      let index = 0;
+      const interval = setInterval(() => {
+        if (index < title.length) {
+          animatedTitle.value = title.slice(0, index + 1);
+          index++;
+        } else {
+          clearInterval(interval);
+          animatedTitle.value = null;
+          resolve();
+        }
+      }, 30);
+    });
+  };
+  const generateTitle = async () => {
+    if (!currentConversation.value || titleGenerated.value)
+      return;
+    const titleMessages = selectTitleGenerationMessages(messages.value);
+    if (!titleMessages)
+      return;
+    titleGenerated.value = true;
+    generatingTitle.value = true;
+    try {
+      const { title } = await $fetch(
+        chatApi.path("/conversations/generate-title"),
+        chatApi.withChatHeaders({
+          method: "POST",
+          body: {
+            userMessage: titleMessages.userMessage.content,
+            assistantResponse: titleMessages.assistantMessage.content
+          }
+        })
+      );
+      if (title && currentConversation.value) {
+        await animateTitle(title);
+        await $fetch(chatApi.path(`/conversations/${currentConversation.value.id}`), {
+          ...chatApi.withChatHeaders({
+            method: "PATCH",
+            body: { title }
+          })
+        });
+        currentConversation.value = {
+          ...currentConversation.value,
+          title
+        };
+      }
+    } catch (err) {
+      Sentry.captureException(err);
+    } finally {
+      generatingTitle.value = false;
+      animatedTitle.value = null;
+    }
+  };
+  const exportToMarkdown = () => {
+    if (!currentConversation.value)
+      return;
+    exportConversationToMarkdown({
+      ...currentConversation.value,
+      messages: messages.value
+    });
+  };
+  watch(hasPendingMessage, (isPending, wasPending) => {
+    if (wasPending && !isPending) {
+      void generateTitle();
+    }
+  });
+  onUnmounted(() => {
+    stopPolling();
+  });
+  return {
+    currentConversation: readonly(currentConversation),
+    messages: processedMessages,
+    loading: readonly(loading),
+    sending: readonly(sending),
+    error: readonly(error),
+    isPolling: readonly(isPolling),
+    hasPendingMessage,
+    cancelling: readonly(cancelling),
+    generatingTitle: readonly(generatingTitle),
+    animatedTitle: readonly(animatedTitle),
+    loadConversation,
+    setConversation,
+    sendMessage,
+    retryMessage,
+    cancelConversation,
+    startPolling,
+    stopPolling,
+    clearConversation,
+    clearConversationThread,
+    exportToMarkdown
+  };
+}

package/dist/runtime/messages/composables/input-history.d.ts

@@ -0,0 +1,7 @@
+import type { Message } from '../../types/schemas/chat/conversations.js';
+export declare function useInputHistory(messages: Ref<Message[]>): {
+    navigateUp: (currentContent: string) => string | null;
+    navigateDown: () => string | null;
+    resetNavigation: () => void;
+    isNavigating: any;
+};

package/dist/runtime/messages/composables/mention-autocomplete.d.ts

@@ -0,0 +1,16 @@
+import type { MentionItem } from '../../types/schemas/chat/ui.js';
+type UseMentionAutocompleteOptions = {
+    editorRef: Ref<HTMLElement | null>;
+    fileItems: ComputedRef<MentionItem[]>;
+    skillItems: ComputedRef<MentionItem[]>;
+    disabled?: Ref<boolean | undefined>;
+    onInsert?: () => void;
+};
+export declare function isMentionTriggerBoundary(textBeforeTrigger: string): boolean;
+export declare function findMentionTrigger(textBeforeCursor: string): {
+    trigger: '@' | '/';
+    query: string;
+    offset: number;
+} | null;
+export declare function useMentionAutocomplete(options: UseMentionAutocompleteOptions): any;
+export {};

package/dist/runtime/messages/composables/selected-model.d.ts

@@ -0,0 +1,4 @@
+import type { Conversation } from '../../types/schemas/chat/conversations.js';
+type ConversationModelTarget = Pick<Conversation, 'id' | 'model'>;
+export declare function useSelectedModel<T extends ConversationModelTarget>(conversation?: Readonly<Ref<T | null | undefined>>): any;
+export {};

package/dist/runtime/messages/composables/selected-model.js

@@ -0,0 +1,48 @@
+import { defaultChatModel } from "../../types/schemas/chat/models.js";
+import { useChatApi } from "../../shared/composables/chat-api.js";
+import { useStatusToast } from "../../shared/composables/status-toast.js";
+export function useSelectedModel(conversation) {
+  const chatApi = useChatApi();
+  const statusToast = useStatusToast();
+  const override = ref(null);
+  let requestSeq = 0;
+  if (conversation) {
+    watch(() => conversation.value?.id, () => {
+      override.value = null;
+    });
+  }
+  const model = computed({
+    get() {
+      if (override.value) {
+        return override.value;
+      }
+      if (conversation?.value?.model) {
+        return conversation.value.model;
+      }
+      return defaultChatModel;
+    },
+    set(value) {
+      const previous = override.value;
+      override.value = value;
+      if (conversation?.value?.id) {
+        const seq = ++requestSeq;
+        $fetch(
+          chatApi.path(`/conversations/${conversation.value.id}`),
+          chatApi.withChatHeaders({
+            method: "PATCH",
+            body: { model: value }
+          })
+        ).catch(() => {
+          if (seq !== requestSeq)
+            return;
+          override.value = previous;
+          statusToast.update({
+            text: "Erro ao salvar modelo selecionado",
+            icon: "i-ph-warning"
+          });
+        });
+      }
+    }
+  });
+  return model;
+}

package/dist/runtime/messages/input-readiness.d.ts

@@ -0,0 +1,14 @@
+import type { TelaAgentInputVariable } from '../types/schemas/integrations/tela-agent-api.js';
+export type AgentInputPendingFile = {
+    inputName?: string | null;
+};
+export type AgentInputReadiness = {
+    ready: boolean;
+    missingRequiredInputs: boolean;
+    hasUnmappedFiles: boolean;
+};
+export declare function getAgentInputReadiness(options: {
+    inputVariables: readonly TelaAgentInputVariable[];
+    inputTexts: Record<string, string | undefined>;
+    files: readonly AgentInputPendingFile[];
+}): AgentInputReadiness;

package/dist/runtime/messages/message-reasoning.d.ts

@@ -0,0 +1,11 @@
+import type { Message } from '../types/schemas/chat/conversations.js';
+import type { ReasoningStep } from './reasoning.js';
+export type ReasoningCache = {
+    bySignature: Map<string, ReasoningStep[]>;
+    byReference: WeakMap<unknown[], {
+        messageId: string;
+        parsedSteps: ReasoningStep[];
+    }>;
+};
+export declare function createReasoningCache(): ReasoningCache;
+export declare function resolveReasoningDisplayMessages(messages: Message[], cache?: ReasoningCache): Message[];

package/dist/runtime/messages/message-reasoning.js

@@ -0,0 +1,179 @@
+export function createReasoningCache() {
+  return {
+    bySignature: /* @__PURE__ */ new Map(),
+    byReference: /* @__PURE__ */ new WeakMap()
+  };
+}
+function getReasoningStepKey(step) {
+  if (typeof step === "string")
+    return `text:${step.slice(0, 100)}`;
+  return `tool:${step.toolUse.id}`;
+}
+function groupReasoningSteps(parsedSteps) {
+  const grouped = [];
+  const pendingToolUses = /* @__PURE__ */ new Map();
+  for (const step of parsedSteps) {
+    if (typeof step === "string") {
+      grouped.push(step);
+    } else if ("name" in step && "input" in step) {
+      pendingToolUses.set(step.id, step);
+      grouped.push({
+        type: "tool_group",
+        toolUse: step
+      });
+    } else if ("output" in step) {
+      const toolUse = pendingToolUses.get(step.id);
+      if (toolUse) {
+        for (let i = grouped.length - 1; i >= 0; i--) {
+          const item = grouped[i];
+          if (typeof item === "object" && item.type === "tool_group" && item.toolUse.id === step.id) {
+            item.toolResult = step;
+            break;
+          }
+        }
+        pendingToolUses.delete(step.id);
+      } else {
+        grouped.push({
+          type: "tool_group",
+          toolUse: { id: step.id, name: "Unknown Tool", input: {} },
+          toolResult: step
+        });
+      }
+    }
+  }
+  return grouped;
+}
+function getReasoningCacheKey(messageId, reasoningData) {
+  return `${messageId}:${JSON.stringify(reasoningData)}`;
+}
+function getParsedReasoningSteps(cache, messageId, reasoningData) {
+  const referenceHit = cache.byReference.get(reasoningData);
+  if (referenceHit?.messageId === messageId)
+    return referenceHit.parsedSteps;
+  const cacheKey = getReasoningCacheKey(messageId, reasoningData);
+  let parsedSteps = cache.bySignature.get(cacheKey);
+  if (!parsedSteps) {
+    parsedSteps = parseReasoningFromPolling(reasoningData);
+    cache.bySignature.set(cacheKey, parsedSteps);
+  }
+  cache.byReference.set(reasoningData, { messageId, parsedSteps });
+  return parsedSteps;
+}
+function parseReasoningFromPolling(reasoning) {
+  const allSteps = [];
+  const seenContentIds = /* @__PURE__ */ new Set();
+  const seenTexts = /* @__PURE__ */ new Set();
+  for (const item of reasoning) {
+    if (!item || typeof item !== "object")
+      continue;
+    const itemObj = item;
+    if (itemObj.type === "user" && itemObj.message) {
+      const message = itemObj.message;
+      if (Array.isArray(message.content)) {
+        for (const contentPart of message.content) {
+          if (!contentPart || typeof contentPart !== "object")
+            continue;
+          const part = contentPart;
+          if (part.type === "tool_result" && part.tool_use_id) {
+            const toolId = part.tool_use_id;
+            if (seenContentIds.has(`tool_result:${toolId}`))
+              continue;
+            seenContentIds.add(`tool_result:${toolId}`);
+            const output = typeof part.content === "string" ? part.content : Array.isArray(part.content) ? part.content[0]?.text ?? "" : "";
+            allSteps.push({
+              id: toolId,
+              output,
+              isError: part.is_error ?? false
+            });
+          }
+        }
+      }
+      continue;
+    }
+    if (itemObj.type === "assistant" && itemObj.message) {
+      const message = itemObj.message;
+      if (!Array.isArray(message.content))
+        continue;
+      for (const contentPart of message.content) {
+        if (!contentPart || typeof contentPart !== "object")
+          continue;
+        const part = contentPart;
+        if (part.type === "text" && typeof part.text === "string") {
+          if (seenTexts.has(part.text))
+            continue;
+          seenTexts.add(part.text);
+          allSteps.push(part.text);
+        } else if (part.type === "tool_use" && part.id && part.name) {
+          const toolId = part.id;
+          if (seenContentIds.has(`tool_use:${toolId}`))
+            continue;
+          seenContentIds.add(`tool_use:${toolId}`);
+          allSteps.push({
+            id: toolId,
+            name: part.name,
+            input: part.input ?? {}
+          });
+        } else if (part.type === "tool_result" && part.tool_use_id) {
+          const toolId = part.tool_use_id;
+          if (seenContentIds.has(`tool_result:${toolId}`))
+            continue;
+          seenContentIds.add(`tool_result:${toolId}`);
+          const output = typeof part.content === "string" ? part.content : Array.isArray(part.content) ? part.content[0]?.text ?? "" : "";
+          allSteps.push({
+            id: toolId,
+            output,
+            isError: part.is_error ?? false
+          });
+        }
+      }
+    } else if (itemObj.type === "text" && typeof itemObj.text === "string") {
+      if (seenTexts.has(itemObj.text))
+        continue;
+      seenTexts.add(itemObj.text);
+      allSteps.push(itemObj.text);
+    } else if (itemObj.type === "tool_use" && itemObj.id && itemObj.name) {
+      const toolId = itemObj.id;
+      if (seenContentIds.has(`tool_use:${toolId}`))
+        continue;
+      seenContentIds.add(`tool_use:${toolId}`);
+      allSteps.push({
+        id: toolId,
+        name: itemObj.name,
+        input: itemObj.input ?? {}
+      });
+    } else if (itemObj.type === "tool_result" && itemObj.tool_use_id) {
+      const toolId = itemObj.tool_use_id;
+      if (seenContentIds.has(`tool_result:${toolId}`))
+        continue;
+      seenContentIds.add(`tool_result:${toolId}`);
+      const output = typeof itemObj.content === "string" ? itemObj.content : Array.isArray(itemObj.content) ? itemObj.content[0]?.text ?? "" : "";
+      allSteps.push({
+        id: toolId,
+        output,
+        isError: itemObj.is_error ?? false
+      });
+    }
+  }
+  return groupReasoningSteps(allSteps);
+}
+export function resolveReasoningDisplayMessages(messages, cache = createReasoningCache()) {
+  const renderedSteps = /* @__PURE__ */ new Set();
+  return messages.map((message) => {
+    if (message.role !== "assistant" || !message.reasoningData || !Array.isArray(message.reasoningData))
+      return message;
+    const parsedSteps = getParsedReasoningSteps(cache, message.id, message.reasoningData);
+    const displaySteps = [];
+    for (const step of parsedSteps) {
+      const key = getReasoningStepKey(step);
+      if (renderedSteps.has(key))
+        continue;
+      if (typeof step === "string" && message.content && step === message.content)
+        continue;
+      renderedSteps.add(key);
+      displaySteps.push(step);
+    }
+    if (displaySteps.length === 0)
+      return { ...message, reasoningData: null };
+    return { ...message, reasoningData: displaySteps };
+  });
+}

package/dist/runtime/messages/message-state.d.ts

@@ -0,0 +1,13 @@
+import type { Message } from '../types/schemas/chat/conversations.js';
+export declare const INTERRUPTED_GENERATION_TEXT = "_Gera\u00E7\u00E3o interrompida pelo usu\u00E1rio_";
+export declare function markPendingAssistantMessagesInterrupted(messages: Message[]): Message[];
+export declare function beginAssistantMessageRetry(messages: Message[], messageId: string): {
+    messages: Message[];
+    originalMessage: Message;
+} | null;
+export declare function restoreAssistantMessageAfterRetryFailure(messages: Message[], originalMessage: Message): Message[];
+export declare function selectTitleGenerationMessages(messages: Message[]): {
+    userMessage: Message;
+    assistantMessage: Message;
+} | null;
+export declare function shouldTreatLoadedConversationTitleAsGenerated(messages: Message[]): boolean;