@meistrari/chat-nuxt 1.0.0

package/dist/runtime/composables/useChat.js

@@ -0,0 +1,512 @@
+import * as Sentry from "@sentry/nuxt";
+import { exportConversationToMarkdown } from "../utils/export-conversation.js";
+import { addFilesToConversation } from "./useConversationFiles.js";
+function getStepKey(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;
+}
+const reasoningCache = /* @__PURE__ */ new Map();
+function getCacheKey(messageId, reasoningData) {
+  return `${messageId}:${reasoningData.length}`;
+}
+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 useChat() {
+  const chatApi = useChatApi();
+  const currentConversation = ref(null);
+  const messages = ref([]);
+  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 processedMessages = computed(() => {
+    const renderedSteps = /* @__PURE__ */ new Set();
+    return messages.value.map((msg) => {
+      if (msg.role !== "assistant" || !msg.reasoningData || !Array.isArray(msg.reasoningData)) {
+        return msg;
+      }
+      const cacheKey = getCacheKey(msg.id, msg.reasoningData);
+      let allSteps = reasoningCache.get(cacheKey);
+      if (!allSteps) {
+        allSteps = parseReasoningFromPolling(msg.reasoningData);
+        reasoningCache.set(cacheKey, allSteps);
+      }
+      const newSteps = [];
+      for (const step of allSteps) {
+        const key = getStepKey(step);
+        if (renderedSteps.has(key))
+          continue;
+        if (typeof step === "string" && msg.content && step === msg.content)
+          continue;
+        renderedSteps.add(key);
+        newSteps.push(step);
+      }
+      if (newSteps.length === 0) {
+        return { ...msg, reasoningData: null };
+      }
+      return { ...msg, reasoningData: newSteps };
+    });
+  });
+  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 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;
+      const completedUserMessages = data.messages.filter((m) => m.role === "user" && m.status === "completed");
+      const completedAssistantMessages = data.messages.filter((m) => m.role === "assistant" && m.status === "completed");
+      if (completedUserMessages.length > 1 || completedAssistantMessages.length > 1) {
+        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) => {
+    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: 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 response = await $fetch(
+        chatApi.path(`/conversations/${currentConversation.value.id}/messages`),
+        chatApi.withChatHeaders({
+          method: "POST",
+          body: { content, files, model }
+        })
+      );
+      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 = messages.value.map((msg) => {
+        if (msg.status === "pending" && msg.role === "assistant") {
+          return {
+            ...msg,
+            content: "_Gera\xE7\xE3o interrompida pelo usu\xE1rio_",
+            status: "completed"
+          };
+        }
+        return msg;
+      });
+      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 messageIndex = messages.value.findIndex((m) => m.id === messageId);
+    if (messageIndex === -1)
+      return false;
+    const message = messages.value[messageIndex];
+    if (!message || message.status !== "failed" || message.role !== "assistant")
+      return false;
+    messages.value = messages.value.map((m) => {
+      if (m.id === messageId) {
+        return { ...m, content: "", status: "pending", reasoningData: null };
+      }
+      return m;
+    });
+    try {
+      await $fetch(
+        chatApi.path(`/conversations/${currentConversation.value.id}/messages/${messageId}/retry`),
+        chatApi.withChatHeaders({ method: "POST" })
+      );
+      startPolling();
+      return true;
+    } catch (err) {
+      messages.value = messages.value.map((m) => {
+        if (m.id === messageId) {
+          return { ...m, content: message.content, status: "failed" };
+        }
+        return m;
+      });
+      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 userMessages = messages.value.filter((m) => m.role === "user" && m.status === "completed");
+    const assistantMessages = messages.value.filter((m) => m.role === "assistant" && m.status === "completed");
+    if (userMessages.length !== 1 || assistantMessages.length !== 1)
+      return;
+    const userMessage = userMessages[0];
+    const assistantMessage = assistantMessages[0];
+    if (!userMessage?.content || !assistantMessage?.content)
+      return;
+    titleGenerated.value = true;
+    generatingTitle.value = true;
+    try {
+      const { title } = await $fetch(
+        chatApi.path("/conversations/generate-title"),
+        chatApi.withChatHeaders({
+          method: "POST",
+          body: {
+            userMessage: userMessage.content,
+            assistantResponse: 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,
+    sendMessage,
+    retryMessage,
+    cancelConversation,
+    startPolling,
+    stopPolling,
+    clearConversation,
+    clearConversationThread,
+    exportToMarkdown
+  };
+}

package/dist/runtime/composables/useChatApi.d.ts

@@ -0,0 +1,6 @@
+export declare function useChatApi(): {
+    path: (routePath: string) => string;
+    withChatHeaders: <const T extends Record<string, any>>(options?: T) => T & {
+        headers?: Record<string, string>;
+    };
+};

package/dist/runtime/composables/useChatApi.js

@@ -0,0 +1,28 @@
+export function useChatApi() {
+  const embedConfig = useEmbedConfig();
+  function buildHeaders(headers) {
+    const mergedHeaders = {
+      ...headers ?? {}
+    };
+    const workspaceId = embedConfig?.workspaceId.value.trim();
+    if (workspaceId) {
+      mergedHeaders["x-chat-workspace-id"] = workspaceId;
+    }
+    return Object.keys(mergedHeaders).length > 0 ? mergedHeaders : void 0;
+  }
+  function withChatHeaders(options) {
+    const headers = buildHeaders(options?.headers);
+    const baseOptions = options ?? {};
+    return {
+      ...baseOptions,
+      ...headers ? { headers } : {}
+    };
+  }
+  function path(routePath) {
+    return `/api/chat${routePath}`;
+  }
+  return {
+    path,
+    withChatHeaders
+  };
+}

package/dist/runtime/composables/useConversationFiles.d.ts

@@ -0,0 +1,13 @@
+import type { MessageFile, MessageRole } from '../types/chat.js';
+export declare function addFilesToConversation(conversationId: string, newFiles: MessageFile[], messageId: string, messageRole: MessageRole): void;
+export declare function useConversationFiles(conversationId: Ref<string | null | undefined>): {
+    files: any;
+    total: any;
+    loading: any;
+    error: any;
+    hasFiles: any;
+    imageFiles: any;
+    documentFiles: any;
+    otherFiles: any;
+    fetchFiles: () => Promise<void>;
+};

package/dist/runtime/composables/useConversationFiles.js

@@ -0,0 +1,98 @@
+import { generateFileId } from "../utils/file.js";
+const sharedFiles = useState("conversationFiles", () => ({}));
+const sharedLoading = useState("conversationFilesLoading", () => ({}));
+const sharedError = useState("conversationFilesError", () => ({}));
+export function addFilesToConversation(conversationId, newFiles, messageId, messageRole) {
+  const current = sharedFiles.value[conversationId] ?? [];
+  const filesToAdd = newFiles.filter((f) => !current.some((existing) => existing.url === f.url)).map((f) => ({
+    id: generateFileId(f.url),
+    url: f.url,
+    name: f.name,
+    mimeType: f.mimeType ?? "application/octet-stream",
+    source: "message",
+    messageId,
+    messageRole,
+    createdAt: /* @__PURE__ */ new Date(),
+    size: f.size
+  }));
+  if (filesToAdd.length > 0) {
+    sharedFiles.value = {
+      ...sharedFiles.value,
+      [conversationId]: [...filesToAdd, ...current]
+    };
+  }
+}
+export function useConversationFiles(conversationId) {
+  const chatApi = useChatApi();
+  const files = computed(() => {
+    const id = conversationId.value;
+    return id ? sharedFiles.value[id] ?? [] : [];
+  });
+  const total = computed(() => files.value.length);
+  const loading = computed(() => {
+    const id = conversationId.value;
+    return id ? sharedLoading.value[id] ?? false : false;
+  });
+  const error = computed(() => {
+    const id = conversationId.value;
+    return id ? sharedError.value[id] ?? null : null;
+  });
+  let currentFetchId = 0;
+  async function fetchFiles() {
+    const id = conversationId.value;
+    if (!id)
+      return;
+    const fetchId = ++currentFetchId;
+    sharedLoading.value = { ...sharedLoading.value, [id]: true };
+    sharedError.value = { ...sharedError.value, [id]: null };
+    try {
+      const response = await $fetch(
+        chatApi.path(`/conversations/${id}/files`),
+        chatApi.withChatHeaders()
+      );
+      if (fetchId === currentFetchId) {
+        sharedFiles.value = { ...sharedFiles.value, [id]: response.files };
+      }
+    } catch (err) {
+      if (fetchId === currentFetchId) {
+        sharedError.value = {
+          ...sharedError.value,
+          [id]: err instanceof Error ? err.message : "Falha ao buscar arquivos"
+        };
+        sharedFiles.value = { ...sharedFiles.value, [id]: [] };
+      }
+    } finally {
+      if (fetchId === currentFetchId) {
+        sharedLoading.value = { ...sharedLoading.value, [id]: false };
+      }
+    }
+  }
+  const hasFiles = computed(() => files.value.length > 0);
+  const imageFiles = computed(
+    () => files.value.filter((f) => f.mimeType.startsWith("image/"))
+  );
+  const documentFiles = computed(
+    () => files.value.filter(
+      (f) => f.mimeType.includes("pdf") || f.mimeType.includes("document") || f.mimeType.includes("spreadsheet") || f.mimeType.includes("presentation")
+    )
+  );
+  const otherFiles = computed(
+    () => files.value.filter(
+      (f) => !f.mimeType.startsWith("image/") && !f.mimeType.includes("pdf") && !f.mimeType.includes("document") && !f.mimeType.includes("spreadsheet") && !f.mimeType.includes("presentation")
+    )
+  );
+  watch(conversationId, () => {
+    fetchFiles();
+  }, { immediate: true });
+  return {
+    files,
+    total,
+    loading,
+    error,
+    hasFiles,
+    imageFiles,
+    documentFiles,
+    otherFiles,
+    fetchFiles
+  };
+}

package/dist/runtime/composables/useConversationFilesPanel.d.ts

@@ -0,0 +1,11 @@
+export declare function useConversationFilesPanel(): {
+    isOpen: any;
+    conversationId: any;
+    panelWidth: any;
+    minPanelWidth: number;
+    maxPanelWidth: number;
+    openPanel: (id: string) => void;
+    closePanel: () => void;
+    togglePanel: (id: string) => void;
+    setPanelWidth: (width: number) => void;
+};