@meistrari/chat-nuxt 1.13.0 → 2.0.0

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

@@ -0,0 +1,23 @@
+import type { DeepReadonly } from 'vue';
+import type { Conversation, ConversationWithMessages } from '../../types/schemas/chat/conversations.js';
+import type { ChatModel } from '../../types/schemas/chat/models.js';
+export declare function mergeFetchedConversations(fetchedConversations: Conversation[], localConversations: readonly Conversation[], deletedConversationIds?: readonly string[], locallyMutatedConversationIds?: readonly string[]): Conversation[];
+export declare function useConversations(): {
+    conversations: any;
+    loading: any;
+    error: any;
+    fetchConversations: (options?: {
+        force?: boolean;
+    }) => Promise<void>;
+    createConversation: (options?: {
+        model?: ChatModel | null;
+    }) => Promise<Conversation | null>;
+    deleteConversation: (id: string) => Promise<boolean>;
+    renameConversation: (id: string, title: string) => Promise<boolean>;
+    moveConversationToGroup: (id: string, groupId: string | null) => Promise<boolean>;
+    duplicateConversation: (id: string) => Promise<ConversationWithMessages | null>;
+    conversationCreatorFilter: any;
+    conversationCreatorFilterCounts: any;
+    updateConversationInList: (updated: Conversation | DeepReadonly<Conversation>) => void;
+    clearGroupFromConversations: (groupId: string) => (() => void);
+};

package/dist/runtime/conversations/composables/conversations.js

@@ -0,0 +1,489 @@
+import { useChatAuth } from "#chat-auth";
+import * as Sentry from "@sentry/nuxt";
+import { defaultChatModel } from "../../types/schemas/chat/models.js";
+import { resolveChatStateScope } from "../scope.js";
+import { useChatApi } from "../../shared/composables/chat-api.js";
+import { useEmbedConfig } from "../../embed/composables/embed-config.js";
+import { useStatusToast } from "../../shared/composables/status-toast.js";
+const CONVERSATION_CREATOR_FILTERS = ["all", "mine"];
+function sortConversationsByUpdatedAt(conversations) {
+  return [...conversations].sort(
+    (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+  );
+}
+export function mergeFetchedConversations(fetchedConversations, localConversations, deletedConversationIds = [], locallyMutatedConversationIds = []) {
+  const deletedIds = new Set(deletedConversationIds);
+  const locallyMutatedIds = new Set(locallyMutatedConversationIds);
+  const mergedById = /* @__PURE__ */ new Map();
+  for (const conversation of fetchedConversations) {
+    if (!deletedIds.has(conversation.id)) {
+      mergedById.set(conversation.id, conversation);
+    }
+  }
+  for (const conversation of localConversations) {
+    if (!deletedIds.has(conversation.id)) {
+      if (!mergedById.has(conversation.id) || locallyMutatedIds.has(conversation.id)) {
+        mergedById.set(conversation.id, conversation);
+      }
+    }
+  }
+  return sortConversationsByUpdatedAt([...mergedById.values()]);
+}
+function bucketValue(bucket, key, fallback) {
+  return bucket.value[key] ?? fallback;
+}
+function setBucketValue(bucket, key, value) {
+  bucket.value = {
+    ...bucket.value,
+    [key]: value
+  };
+}
+function removeBucketValue(bucket, key) {
+  const nextValue = { ...bucket.value };
+  delete nextValue[key];
+  bucket.value = nextValue;
+}
+function hasBucketValue(bucket, key) {
+  return Object.prototype.hasOwnProperty.call(bucket.value, key);
+}
+function conversationBucketKeyForRuntime(runtimeScope, filter) {
+  return `${runtimeScope}:creator:${filter}`;
+}
+function createOptimisticConversationId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return `optimistic-${crypto.randomUUID()}`;
+  }
+  return `optimistic-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+export function useConversations() {
+  const chatApi = useChatApi();
+  const embedConfig = useEmbedConfig();
+  const { user: authUser, activeOrganization } = useChatAuth();
+  const conversationBuckets = useState("conversations", () => ({}));
+  const loadingBuckets = useState("conversations-loading", () => ({}));
+  const errorBuckets = useState("conversations-error", () => ({}));
+  const fetchedBuckets = useState("conversations-fetched", () => ({}));
+  const mutationVersionBuckets = useState("conversations-mutation-version", () => ({}));
+  const deletedIdBuckets = useState("conversations-deleted-ids", () => ({}));
+  const mutatedIdBuckets = useState("conversations-mutated-ids", () => ({}));
+  const metadataBuckets = useState("conversations-metadata", () => ({}));
+  const metadataLoadingBuckets = useState("conversations-metadata-loading", () => ({}));
+  const metadataFetchedBuckets = useState("conversations-metadata-fetched", () => ({}));
+  const conversationCreatorFilter = useState(
+    "conversation-creator-filter",
+    () => embedConfig?.defaultConversationCreatorFilter?.value ?? "all"
+  );
+  const isTelaAgentMode = computed(() => !!embedConfig?.telaAgentId.value);
+  const runtimeScope = computed(() => resolveChatStateScope(
+    embedConfig?.workspaceId.value || activeOrganization.value?.id,
+    embedConfig?.telaAgentId.value,
+    embedConfig?.conversationScope?.value
+  ));
+  const workspaceScope = computed(() => conversationBucketKeyForRuntime(runtimeScope.value, conversationCreatorFilter.value));
+  const conversationCreatorFilterCounts = computed(
+    () => metadataBuckets.value[runtimeScope.value]?.counts ?? { all: 0, mine: 0 }
+  );
+  const conversations = computed({
+    get: () => conversationBuckets.value[workspaceScope.value] ?? [],
+    set: (value) => {
+      conversationBuckets.value = {
+        ...conversationBuckets.value,
+        [workspaceScope.value]: value
+      };
+    }
+  });
+  const loading = computed({
+    get: () => loadingBuckets.value[workspaceScope.value] ?? false,
+    set: (value) => {
+      loadingBuckets.value = {
+        ...loadingBuckets.value,
+        [workspaceScope.value]: value
+      };
+    }
+  });
+  const error = computed({
+    get: () => errorBuckets.value[workspaceScope.value] ?? null,
+    set: (value) => {
+      errorBuckets.value = {
+        ...errorBuckets.value,
+        [workspaceScope.value]: value
+      };
+    }
+  });
+  function markScopeMutated(scope, id) {
+    setBucketValue(mutationVersionBuckets, scope, bucketValue(mutationVersionBuckets, scope, 0) + 1);
+    if (id) {
+      setBucketValue(mutatedIdBuckets, scope, [
+        .../* @__PURE__ */ new Set([...bucketValue(mutatedIdBuckets, scope, []), id])
+      ]);
+    }
+  }
+  function commitConversationsToScope(scope, nextConversations, mutatedId) {
+    setBucketValue(conversationBuckets, scope, sortConversationsByUpdatedAt(nextConversations));
+    markScopeMutated(scope, mutatedId);
+  }
+  function activeAndLoadedRuntimeConversationScopes(scope) {
+    const activeScope = runtimeScope.value === scope ? [workspaceScope.value] : [];
+    const loadedScopes = CONVERSATION_CREATOR_FILTERS.map((filter) => conversationBucketKeyForRuntime(scope, filter)).filter((key) => hasBucketValue(conversationBuckets, key));
+    return [.../* @__PURE__ */ new Set([...activeScope, ...loadedScopes])];
+  }
+  function findConversationInLoadedBuckets(id, runtimeScopeKey) {
+    for (const scope of activeAndLoadedRuntimeConversationScopes(runtimeScopeKey)) {
+      const found = bucketValue(conversationBuckets, scope, []).find((conversation) => conversation.id === id);
+      if (found) {
+        return found;
+      }
+    }
+    return null;
+  }
+  function snapshotConversationBuckets(scopes) {
+    return Object.fromEntries(scopes.map((scope) => [
+      scope,
+      hasBucketValue(conversationBuckets, scope) ? [...bucketValue(conversationBuckets, scope, [])] : void 0
+    ]));
+  }
+  function restoreConversationBuckets(snapshot, mutatedId) {
+    for (const [scope, previousConversations] of Object.entries(snapshot)) {
+      if (previousConversations) {
+        commitConversationsToScope(scope, previousConversations, mutatedId);
+      } else {
+        removeBucketValue(conversationBuckets, scope);
+        markScopeMutated(scope, mutatedId);
+      }
+    }
+  }
+  function upsertConversationInLoadedBuckets(conversation, runtimeScopeKey, replacedId) {
+    for (const scope of activeAndLoadedRuntimeConversationScopes(runtimeScopeKey)) {
+      const filter = CONVERSATION_CREATOR_FILTERS.find((item) => scope === conversationBucketKeyForRuntime(runtimeScopeKey, item));
+      if (!filter || filter === "mine" && conversation.userId !== authUser.value?.id)
+        continue;
+      const currentConversations = bucketValue(conversationBuckets, scope, []);
+      commitConversationsToScope(
+        scope,
+        [
+          conversation,
+          ...currentConversations.filter((item) => item.id !== conversation.id && item.id !== replacedId)
+        ],
+        conversation.id
+      );
+    }
+  }
+  function updateConversationInLoadedBuckets(updated, runtimeScopeKey = runtimeScope.value) {
+    for (const scope of activeAndLoadedRuntimeConversationScopes(runtimeScopeKey)) {
+      const currentConversations = bucketValue(conversationBuckets, scope, []);
+      const index = currentConversations.findIndex((conversation) => conversation.id === updated.id);
+      if (index === -1)
+        continue;
+      const nextConversations = [...currentConversations];
+      nextConversations[index] = updated;
+      commitConversationsToScope(scope, nextConversations, updated.id);
+    }
+  }
+  function removeConversationFromLoadedBuckets(id, runtimeScopeKey) {
+    for (const scope of activeAndLoadedRuntimeConversationScopes(runtimeScopeKey)) {
+      const currentConversations = bucketValue(conversationBuckets, scope, []);
+      if (currentConversations.some((conversation) => conversation.id === id)) {
+        commitConversationsToScope(
+          scope,
+          currentConversations.filter((conversation) => conversation.id !== id),
+          id
+        );
+      }
+    }
+  }
+  function addDeletedConversationIdToScopes(id, scopes) {
+    for (const scope of scopes) {
+      setBucketValue(deletedIdBuckets, scope, [
+        .../* @__PURE__ */ new Set([...bucketValue(deletedIdBuckets, scope, []), id])
+      ]);
+      markScopeMutated(scope);
+    }
+  }
+  function removeDeletedConversationIdFromScopes(id, scopes) {
+    for (const scope of scopes) {
+      setBucketValue(
+        deletedIdBuckets,
+        scope,
+        bucketValue(deletedIdBuckets, scope, []).filter((deletedId) => deletedId !== id)
+      );
+      markScopeMutated(scope);
+    }
+  }
+  function snapshotConversationMetadata(scope) {
+    const metadata = metadataBuckets.value[scope];
+    return metadata ? { counts: { ...metadata.counts } } : void 0;
+  }
+  function restoreConversationMetadata(scope, metadata) {
+    if (metadata) {
+      setBucketValue(metadataBuckets, scope, metadata);
+    } else {
+      removeBucketValue(metadataBuckets, scope);
+    }
+  }
+  function updateConversationCounts(scope, conversation, delta) {
+    const counts = metadataBuckets.value[scope]?.counts ?? { all: 0, mine: 0 };
+    setBucketValue(metadataBuckets, scope, {
+      counts: {
+        all: Math.max(0, counts.all + delta),
+        mine: Math.max(0, counts.mine + (conversation.userId === authUser.value?.id ? delta : 0))
+      }
+    });
+  }
+  const fetchConversationMetadata = async (options = {}) => {
+    const requestScope = runtimeScope.value;
+    if (bucketValue(metadataLoadingBuckets, requestScope, false) || bucketValue(metadataFetchedBuckets, requestScope, false) && !options.force) {
+      return;
+    }
+    setBucketValue(metadataLoadingBuckets, requestScope, true);
+    try {
+      const metadata = await $fetch(
+        chatApi.path("/conversations/metadata"),
+        chatApi.withChatHeaders()
+      );
+      setBucketValue(metadataBuckets, requestScope, metadata);
+      setBucketValue(metadataFetchedBuckets, requestScope, true);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Erro ao carregar metadados das conversas";
+      setBucketValue(errorBuckets, workspaceScope.value, message);
+      Sentry.captureException(err);
+    } finally {
+      setBucketValue(metadataLoadingBuckets, requestScope, false);
+    }
+  };
+  const fetchConversations = async (options = {}) => {
+    const requestScope = workspaceScope.value;
+    const requestCreatorFilter = conversationCreatorFilter.value;
+    const metadataPromise = fetchConversationMetadata({ force: options.force });
+    if (bucketValue(loadingBuckets, requestScope, false) || bucketValue(fetchedBuckets, requestScope, false) && !options.force) {
+      await metadataPromise;
+      return;
+    }
+    setBucketValue(loadingBuckets, requestScope, true);
+    setBucketValue(errorBuckets, requestScope, null);
+    const mutationVersionAtStart = bucketValue(mutationVersionBuckets, requestScope, 0);
+    try {
+      const data = await $fetch(
+        chatApi.path("/conversations"),
+        chatApi.withChatHeaders(requestCreatorFilter === "mine" ? { query: { creator: "me" } } : void 0)
+      );
+      const currentDeletedIds = bucketValue(deletedIdBuckets, requestScope, []);
+      const currentMutatedIds = bucketValue(mutatedIdBuckets, requestScope, []);
+      const visibleData = data.filter((conversation) => !currentDeletedIds.includes(conversation.id));
+      await metadataPromise;
+      if (bucketValue(mutationVersionBuckets, requestScope, 0) === mutationVersionAtStart) {
+        setBucketValue(conversationBuckets, requestScope, sortConversationsByUpdatedAt(visibleData));
+        setBucketValue(mutatedIdBuckets, requestScope, []);
+      } else {
+        setBucketValue(conversationBuckets, requestScope, mergeFetchedConversations(
+          visibleData,
+          bucketValue(conversationBuckets, requestScope, []),
+          currentDeletedIds,
+          currentMutatedIds
+        ));
+        setBucketValue(mutatedIdBuckets, requestScope, []);
+      }
+      const returnedIds = new Set(data.map((conversation) => conversation.id));
+      setBucketValue(deletedIdBuckets, requestScope, currentDeletedIds.filter((id) => returnedIds.has(id)));
+      setBucketValue(fetchedBuckets, requestScope, true);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Erro ao carregar conversas";
+      setBucketValue(errorBuckets, requestScope, message);
+      Sentry.captureException(err);
+    } finally {
+      setBucketValue(loadingBuckets, requestScope, false);
+    }
+  };
+  const createConversation = async (options) => {
+    error.value = null;
+    const requestRuntimeScope = runtimeScope.value;
+    const metadataSnapshot = snapshotConversationMetadata(requestRuntimeScope);
+    const now = /* @__PURE__ */ new Date();
+    const optimisticConversation = {
+      id: createOptimisticConversationId(),
+      workspaceId: embedConfig?.workspaceId.value || activeOrganization.value?.id || "",
+      groupId: null,
+      userId: authUser.value?.id ?? "",
+      title: "Nova conversa",
+      threadSessionId: null,
+      model: isTelaAgentMode.value ? null : options?.model ?? defaultChatModel,
+      appliedSettingsAt: null,
+      appliedSettingsSnapshot: null,
+      telaAgentId: embedConfig?.telaAgentId.value ?? null,
+      createdBy: authUser.value?.email ?? null,
+      conversationScope: embedConfig?.conversationScope?.value ?? null,
+      createdAt: now,
+      updatedAt: now
+    };
+    upsertConversationInLoadedBuckets(optimisticConversation, requestRuntimeScope);
+    updateConversationCounts(requestRuntimeScope, optimisticConversation, 1);
+    try {
+      const conversation = await $fetch(
+        chatApi.path("/conversations"),
+        chatApi.withChatHeaders({
+          method: "POST",
+          body: !isTelaAgentMode.value && options?.model ? { model: options.model } : void 0
+        })
+      );
+      upsertConversationInLoadedBuckets(conversation, requestRuntimeScope, optimisticConversation.id);
+      return conversation;
+    } catch (err) {
+      removeConversationFromLoadedBuckets(optimisticConversation.id, requestRuntimeScope);
+      restoreConversationMetadata(requestRuntimeScope, metadataSnapshot);
+      const message = err instanceof Error ? err.message : "Erro ao criar conversa";
+      error.value = message;
+      return null;
+    }
+  };
+  const deleteConversation = async (id) => {
+    error.value = null;
+    const statusToast = useStatusToast();
+    const requestRuntimeScope = runtimeScope.value;
+    const affectedScopes = activeAndLoadedRuntimeConversationScopes(requestRuntimeScope);
+    const conversationSnapshot = snapshotConversationBuckets(affectedScopes);
+    const metadataSnapshot = snapshotConversationMetadata(requestRuntimeScope);
+    const deletedConversation = findConversationInLoadedBuckets(id, requestRuntimeScope);
+    addDeletedConversationIdToScopes(id, affectedScopes);
+    removeConversationFromLoadedBuckets(id, requestRuntimeScope);
+    if (deletedConversation) {
+      updateConversationCounts(requestRuntimeScope, deletedConversation, -1);
+    }
+    try {
+      await $fetch(
+        chatApi.path(`/conversations/${id}`),
+        chatApi.withChatHeaders({
+          method: "DELETE"
+        })
+      );
+      statusToast.update({
+        text: "Conversa exclu\xEDda",
+        icon: "i-ph-check"
+      });
+      return true;
+    } catch (err) {
+      removeDeletedConversationIdFromScopes(id, affectedScopes);
+      restoreConversationBuckets(conversationSnapshot, id);
+      restoreConversationMetadata(requestRuntimeScope, metadataSnapshot);
+      const message = err instanceof Error ? err.message : "Erro ao deletar conversa";
+      error.value = message;
+      statusToast.update({
+        text: "Erro ao excluir conversa",
+        icon: "i-ph-warning"
+      });
+      return false;
+    }
+  };
+  const updateConversationInList = (updated) => {
+    updateConversationInLoadedBuckets(updated);
+  };
+  const moveConversationToGroup = async (id, groupId) => {
+    error.value = null;
+    const requestRuntimeScope = runtimeScope.value;
+    const affectedScopes = activeAndLoadedRuntimeConversationScopes(requestRuntimeScope);
+    const conversationSnapshot = snapshotConversationBuckets(affectedScopes);
+    const conversation = findConversationInLoadedBuckets(id, requestRuntimeScope);
+    if (!conversation)
+      return false;
+    updateConversationInLoadedBuckets({ ...conversation, groupId }, requestRuntimeScope);
+    try {
+      const updated = await $fetch(
+        chatApi.path(`/conversations/${id}/group`),
+        chatApi.withChatHeaders({
+          method: "PATCH",
+          body: { groupId }
+        })
+      );
+      updateConversationInLoadedBuckets(updated, requestRuntimeScope);
+      return true;
+    } catch (err) {
+      restoreConversationBuckets(conversationSnapshot, id);
+      const message = err instanceof Error ? err.message : "Erro ao mover conversa";
+      error.value = message;
+      Sentry.captureException(err);
+      return false;
+    }
+  };
+  const clearGroupFromConversations = (groupId) => {
+    const affectedScopes = activeAndLoadedRuntimeConversationScopes(runtimeScope.value).filter((scope) => bucketValue(conversationBuckets, scope, []).some((conversation) => conversation.groupId === groupId));
+    const conversationSnapshot = snapshotConversationBuckets(affectedScopes);
+    for (const scope of affectedScopes) {
+      const currentConversations = bucketValue(conversationBuckets, scope, []);
+      commitConversationsToScope(
+        scope,
+        currentConversations.map(
+          (conversation) => conversation.groupId === groupId ? { ...conversation, groupId: null } : conversation
+        )
+      );
+    }
+    return () => restoreConversationBuckets(conversationSnapshot);
+  };
+  const renameConversation = async (id, title) => {
+    error.value = null;
+    const requestRuntimeScope = runtimeScope.value;
+    const affectedScopes = activeAndLoadedRuntimeConversationScopes(requestRuntimeScope);
+    const conversationSnapshot = snapshotConversationBuckets(affectedScopes);
+    const conversation = findConversationInLoadedBuckets(id, requestRuntimeScope);
+    if (!conversation)
+      return false;
+    updateConversationInLoadedBuckets({ ...conversation, title, updatedAt: /* @__PURE__ */ new Date() }, requestRuntimeScope);
+    try {
+      const updated = await $fetch(
+        chatApi.path(`/conversations/${id}`),
+        chatApi.withChatHeaders({
+          method: "PATCH",
+          body: { title }
+        })
+      );
+      updateConversationInLoadedBuckets(updated, requestRuntimeScope);
+      return true;
+    } catch (err) {
+      restoreConversationBuckets(conversationSnapshot, id);
+      const message = err instanceof Error ? err.message : "Erro ao renomear conversa";
+      error.value = message;
+      Sentry.captureException(err);
+      return false;
+    }
+  };
+  const duplicateConversation = async (id) => {
+    error.value = null;
+    const statusToast = useStatusToast();
+    const requestRuntimeScope = runtimeScope.value;
+    try {
+      const duplicated = await $fetch(
+        chatApi.path(`/conversations/${id}/duplicate`),
+        chatApi.withChatHeaders({
+          method: "POST"
+        })
+      );
+      upsertConversationInLoadedBuckets(duplicated, requestRuntimeScope);
+      updateConversationCounts(requestRuntimeScope, duplicated, 1);
+      statusToast.update({
+        text: "Conversa duplicada",
+        icon: "i-ph-check"
+      });
+      return duplicated;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "Erro ao duplicar conversa";
+      error.value = message;
+      statusToast.update({
+        text: "Erro ao duplicar conversa",
+        icon: "i-ph-warning"
+      });
+      return null;
+    }
+  };
+  return {
+    conversations: readonly(conversations),
+    loading: readonly(loading),
+    error: readonly(error),
+    fetchConversations,
+    createConversation,
+    deleteConversation,
+    renameConversation,
+    moveConversationToGroup,
+    duplicateConversation,
+    conversationCreatorFilter,
+    conversationCreatorFilterCounts,
+    updateConversationInList,
+    clearGroupFromConversations
+  };
+}

package/dist/runtime/conversations/composables/pending-conversation-group.js

@@ -0,0 +1,34 @@
+import { useChatAuth } from "#chat-auth";
+import { resolveChatStateScope } from "../scope.js";
+import { useEmbedConfig } from "../../embed/composables/embed-config.js";
+const PENDING_CONVERSATION_GROUP_STATE_KEY = "chat-pending-conversation-group";
+export function usePendingConversationGroup() {
+  const embedConfig = useEmbedConfig();
+  const { activeOrganization } = useChatAuth();
+  const pendingConversationGroups = useState(
+    PENDING_CONVERSATION_GROUP_STATE_KEY,
+    () => ({})
+  );
+  const runtimeScope = computed(() => resolveChatStateScope(
+    embedConfig?.workspaceId.value || activeOrganization.value?.id,
+    embedConfig?.telaAgentId.value,
+    embedConfig?.conversationScope?.value
+  ));
+  const pendingConversationGroupId = computed(
+    () => pendingConversationGroups.value[runtimeScope.value] ?? null
+  );
+  function setPendingConversationGroup(groupId) {
+    pendingConversationGroups.value = {
+      ...pendingConversationGroups.value,
+      [runtimeScope.value]: groupId ?? null
+    };
+  }
+  function clearPendingConversationGroup() {
+    setPendingConversationGroup(null);
+  }
+  return {
+    pendingConversationGroupId,
+    setPendingConversationGroup,
+    clearPendingConversationGroup
+  };
+}

package/dist/runtime/conversations/creator-filter.d.ts

@@ -0,0 +1,5 @@
+import type { ConversationCreatorFilter } from '../types/schemas/chat/primitives.js';
+type ConversationCreatorFilterCounts = Record<ConversationCreatorFilter, number>;
+export declare function resolveConversationCreatorFilterKeyboardTarget(currentFilter: ConversationCreatorFilter, key: string): ConversationCreatorFilter | null;
+export declare function hasConversationCreatorFilterResults(counts: ConversationCreatorFilterCounts): boolean;
+export {};

package/dist/runtime/conversations/creator-filter.js

@@ -0,0 +1,24 @@
+import { conversationCreatorFilterOptions } from "../types/schemas/chat/ui.js";
+const FILTER_NAVIGATION_KEYS = {
+  ArrowLeft: -1,
+  ArrowUp: -1,
+  ArrowRight: 1,
+  ArrowDown: 1
+};
+export function resolveConversationCreatorFilterKeyboardTarget(currentFilter, key) {
+  const filters = conversationCreatorFilterOptions.map((option) => option.value);
+  if (key === "Home")
+    return filters[0] ?? null;
+  if (key === "End")
+    return filters.at(-1) ?? null;
+  if (!(key in FILTER_NAVIGATION_KEYS))
+    return null;
+  const currentIndex = filters.indexOf(currentFilter);
+  if (currentIndex === -1)
+    return null;
+  const direction = FILTER_NAVIGATION_KEYS[key];
+  return filters[(currentIndex + direction + filters.length) % filters.length] ?? null;
+}
+export function hasConversationCreatorFilterResults(counts) {
+  return conversationCreatorFilterOptions.some((option) => counts[option.value] > 0);
+}

package/dist/runtime/conversations/creator.d.ts

@@ -0,0 +1,5 @@
+import type { ChatActor } from '../embed/types.js';
+export declare function resolveConversationCreator(conversationUserId: string | null | undefined, options: {
+    currentUser?: ChatActor | null;
+    getMember?: (userId: string) => ChatActor | undefined;
+}): ChatActor | null;

package/dist/runtime/conversations/creator.js

@@ -0,0 +1,10 @@
+const REMOVED_CONVERSATION_CREATOR = {
+  name: "Usuario removido"
+};
+export function resolveConversationCreator(conversationUserId, options) {
+  if (conversationUserId) {
+    const member = options.getMember?.(conversationUserId);
+    return member ?? REMOVED_CONVERSATION_CREATOR;
+  }
+  return options.currentUser ?? null;
+}

package/dist/runtime/conversations/date-groups.d.ts

@@ -0,0 +1,6 @@
+export declare function groupConversationsByDate<T extends {
+    updatedAt: Date | string;
+}>(items: readonly T[]): {
+    title: string;
+    items: T[];
+}[];

package/dist/runtime/conversations/date-groups.js

@@ -0,0 +1,36 @@
+export function groupConversationsByDate(items) {
+  const now = /* @__PURE__ */ new Date();
+  const todayStart = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+  const yesterdayStart = todayStart - 864e5;
+  const last7DaysStart = todayStart - 7 * 864e5;
+  const last30DaysStart = todayStart - 30 * 864e5;
+  const last3MonthsStart = new Date(now.getFullYear(), now.getMonth() - 3, now.getDate()).getTime();
+  const lastYearStart = new Date(now.getFullYear() - 1, now.getMonth(), now.getDate()).getTime();
+  const groups = {
+    "Hoje": [],
+    "Ontem": [],
+    "\xDAltimos 7 dias": [],
+    "\xDAltimos 30 dias": [],
+    "\xDAltimos 3 meses": [],
+    "1 ano atr\xE1s": [],
+    "Anteriores": []
+  };
+  for (const item of items) {
+    const time = new Date(item.updatedAt).getTime();
+    if (time >= todayStart)
+      groups.Hoje?.push(item);
+    else if (time >= yesterdayStart)
+      groups.Ontem?.push(item);
+    else if (time >= last7DaysStart)
+      groups["\xDAltimos 7 dias"]?.push(item);
+    else if (time >= last30DaysStart)
+      groups["\xDAltimos 30 dias"]?.push(item);
+    else if (time >= last3MonthsStart)
+      groups["\xDAltimos 3 meses"]?.push(item);
+    else if (time >= lastYearStart)
+      groups["1 ano atr\xE1s"]?.push(item);
+    else
+      groups.Anteriores?.push(item);
+  }
+  return Object.entries(groups).filter(([_, items2]) => items2.length > 0).map(([title, items2]) => ({ title, items: items2 }));
+}

package/dist/runtime/conversations/export.d.ts

@@ -0,0 +1,2 @@
+import type { ConversationWithMessages } from '../types/schemas/chat/conversations.js';
+export declare function exportConversationToMarkdown(conversation: ConversationWithMessages): void;

package/dist/runtime/conversations/scope.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeConversationId(value: string | null | undefined): string | null;
+export declare function normalizeTelaAgentId(value: string | null | undefined): string | null;
+export declare function normalizeConversationScope(value: string | null | undefined): string | null;
+export declare function resolveConversationScopeKeySegment(value: string | null | undefined): string;
+export declare function resolveChatStateScope(workspaceId: string | null | undefined, telaAgentId: string | null | undefined, conversationScope?: string | null): string;

package/dist/runtime/conversations/scope.js

@@ -0,0 +1,22 @@
+export function normalizeConversationId(value) {
+  const normalized = value?.trim();
+  return normalized || null;
+}
+export function normalizeTelaAgentId(value) {
+  const normalized = value?.trim();
+  return normalized || null;
+}
+export function normalizeConversationScope(value) {
+  const normalized = value?.trim();
+  return normalized || null;
+}
+export function resolveConversationScopeKeySegment(value) {
+  const normalizedConversationScope = normalizeConversationScope(value);
+  return normalizedConversationScope ? `value:${normalizedConversationScope}` : "none";
+}
+export function resolveChatStateScope(workspaceId, telaAgentId, conversationScope) {
+  const normalizedWorkspaceId = workspaceId?.trim() || "default";
+  const normalizedTelaAgentId = normalizeTelaAgentId(telaAgentId);
+  const runtimeScope = normalizedTelaAgentId ? `${normalizedWorkspaceId}:tela-agent:${normalizedTelaAgentId}` : `${normalizedWorkspaceId}:default-chat`;
+  return `${runtimeScope}:scope:${resolveConversationScopeKeySegment(conversationScope)}`;
+}