@meistrari/chat-nuxt 1.11.0 → 1.12.0

package/dist/runtime/embed/components/ChatEmbedInner.vue

@@ -25,7 +25,7 @@ const chatAction = useChatAction();
 const { user: authUser, activeOrganization, logout } = useChatAuth();
 const { getMember, getMemberImage } = useWorkspaceMembers();
 const statusToast = useStatusToast();
-const { conversations, loading: conversationsLoading, fetchConversations, createConversation, deleteConversation, renameConversation, duplicateConversation, updateConversationInList } = useConversations();
+const { conversations, loading: conversationsLoading, fetchConversations, createConversation, deleteConversation, renameConversation, duplicateConversation, moveConversationToGroup, updateConversationInList } = useConversations();
 const { settings: workspaceSettingsState, fetchSettings } = useWorkspaceSettings();
 const { metadata: telaAgentMetadata, loading: telaAgentMetadataLoading, fetchAgentMetadata } = useTelaAgentMetadata();
 const isTelaAgentMode = computed(() => !!embedConfig?.telaAgentId.value);
@@ -46,6 +46,11 @@ const activeConversationId = ref(
 );
 const loadingConversationId = ref(null);
 const isReady = ref(false);
+const {
+  pendingConversationGroupId,
+  setPendingConversationGroup,
+  clearPendingConversationGroup
+} = usePendingConversationGroup();
 const resolvedFeatures = computed(() => resolveChatFeatures(props.features));
 const dropZoneRef = ref(null);
 const activeTab = ref("chat");
@@ -154,6 +159,7 @@ async function openConversation(nextConversationId) {
   if (!normalizedConversationId) {
     return;
   }
+  clearPendingConversationGroup();
   if (activeConversationId.value !== normalizedConversationId) {
     closePreview();
   }
@@ -165,6 +171,9 @@ watch(() => props.conversationId, async (nextConversationId) => {
     return;
   }
   const normalizedConversationId = normalizeConversationId(nextConversationId);
+  if (normalizedConversationId) {
+    clearPendingConversationGroup();
+  }
   if (!isReady.value) {
     syncConversationId(normalizedConversationId);
     return;
@@ -272,7 +281,14 @@ async function handleSend(content, files, model, agentInputs) {
     const conversation = await createConversation(isTelaAgentMode.value ? void 0 : { model: model ?? selectedModel.value });
     if (!conversation)
       return;
-    setConversation(conversation);
+    const groupId = pendingConversationGroupId.value;
+    clearPendingConversationGroup();
+    if (groupId && await moveConversationToGroup(conversation.id, groupId)) {
+      const groupedConversation = { ...conversation, groupId };
+      setConversation(groupedConversation);
+    } else {
+      setConversation(conversation);
+    }
     createdConversationId = conversation.id;
   }
   if (!currentConversation.value)
@@ -286,7 +302,8 @@ async function handleSend(content, files, model, agentInputs) {
 async function handleRetry(messageId) {
   await retryMessage(messageId);
 }
-async function handleNewConversation() {
+async function handleNewConversation(groupId) {
+  setPendingConversationGroup(groupId);
   resetConversation();
 }
 const workspaceSheetOpen = ref(false);
@@ -407,10 +424,10 @@ async function handleDelete() {
             w-240px h-full flex="~ col" flex-shrink-0
             bg-neutral-50 b-r=".5px neutral-200"
         >
-            <div px-12px pt-16px pb-8px flex="~ col" gap-8px>
+            <div px-12px pt-16px pb-8px flex gap-8px>
                 <button
                     flex items-center justify-center gap-6px
-                    h-32px px-12px w-full
+                    h-32px px-12px flex-1 min-w-0
                     bg-white b=".5px neutral-300" rounded-10px
                     hover:bg-neutral-50 transition-colors cursor-pointer
                     @click="handleNewConversation"
@@ -420,6 +437,7 @@ async function handleDelete() {
                         Nova conversa
                     </span>
                 </button>
+                <ChatConversationNewGroupButton />
             </div>
 
             <div flex-1 overflow-y-auto px-4px>
@@ -429,6 +447,7 @@ async function handleDelete() {
                     :get-member-image="getMemberImage"
                     :select-conversation="openConversation"
                     :reset-conversation="handleNewConversation"
+                    :start-conversation="handleNewConversation"
                     :loading="conversationsLoading"
                 />
             </div>

package/dist/runtime/server/api/chat/conversations/[id]/group.patch.d.ts

@@ -0,0 +1 @@
+export { default } from '../../../conversations/[id]/group.patch.js';

package/dist/runtime/server/api/chat/conversations/[id]/group.patch.js

@@ -0,0 +1 @@
+export { default } from "../../../conversations/[id]/group.patch.js";

package/dist/runtime/server/api/chat/conversations/groups/[groupId]/index.delete.d.ts

@@ -0,0 +1 @@
+export { default } from '../../../../conversations/groups/[groupId]/index.delete.js';

package/dist/runtime/server/api/chat/conversations/groups/[groupId]/index.delete.js

@@ -0,0 +1 @@
+export { default } from "../../../../conversations/groups/[groupId]/index.delete.js";

package/dist/runtime/server/api/chat/conversations/groups/[groupId]/index.patch.d.ts

@@ -0,0 +1 @@
+export { default } from '../../../../conversations/groups/[groupId]/index.patch.js';

package/dist/runtime/server/api/chat/conversations/groups/[groupId]/index.patch.js

@@ -0,0 +1 @@
+export { default } from "../../../../conversations/groups/[groupId]/index.patch.js";

package/dist/runtime/server/api/chat/conversations/groups/index.get.d.ts

@@ -0,0 +1 @@
+export { default } from '../../../conversations/groups/index.get.js';

package/dist/runtime/server/api/chat/conversations/groups/index.get.js

@@ -0,0 +1 @@
+export { default } from "../../../conversations/groups/index.get.js";

package/dist/runtime/server/api/chat/conversations/groups/index.post.d.ts

@@ -0,0 +1 @@
+export { default } from '../../../conversations/groups/index.post.js';

package/dist/runtime/server/api/chat/conversations/groups/index.post.js

@@ -0,0 +1 @@
+export { default } from "../../../conversations/groups/index.post.js";

package/dist/runtime/server/api/conversations/[id]/duplicate.post.js

@@ -26,6 +26,7 @@ export default defineEventHandler(async (event) => {
   const duplicated = await db.transaction(async (tx) => {
     const [newConversation] = await tx.insert(schema.conversations).values({
       workspaceId: context.workspaceId,
+      groupId: null,
       userId: context.user.id,
       title: `${original.title} (copy)`,
       createdBy: context.user.email,

package/dist/runtime/server/api/conversations/[id]/group.patch.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/conversations/[id]/group.patch.js

@@ -0,0 +1,46 @@
+import { createError, defineEventHandler, getRouterParam, readBody } from "h3";
+import { useDb, schema } from "#chat-runtime/server/db";
+import { resolveChatRuntimeContext } from "#chat-runtime/server/utils/chat-context";
+import { resolveOptionalConversationGroupId, conversationGroupScopeConditions } from "#chat-runtime/server/utils/conversation-group";
+import { conversationScopeConditions } from "#chat-runtime/server/utils/conversation-scope";
+import { logger } from "#chat-runtime/server/utils/logger";
+function hasGroupId(body) {
+  return !!body && typeof body === "object" && Object.prototype.hasOwnProperty.call(body, "groupId");
+}
+export default defineEventHandler(async (event) => {
+  const context = resolveChatRuntimeContext(event);
+  const db = useDb();
+  const id = getRouterParam(event, "id");
+  if (!id) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Conversation ID is required"
+    });
+  }
+  const body = await readBody(event);
+  if (!hasGroupId(body)) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Group ID is required"
+    });
+  }
+  const groupId = resolveOptionalConversationGroupId(body.groupId);
+  if (groupId) {
+    const [group] = await db.select({ id: schema.conversationGroups.id }).from(schema.conversationGroups).where(conversationGroupScopeConditions(context, groupId)).limit(1);
+    if (!group) {
+      throw createError({
+        statusCode: 404,
+        statusMessage: "Conversation group not found"
+      });
+    }
+  }
+  const [updated] = await db.update(schema.conversations).set({ groupId }).where(conversationScopeConditions(context, id)).returning();
+  if (!updated) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Conversation not found"
+    });
+  }
+  logger.info({ conversationId: id, groupId, workspaceId: context.workspaceId }, "Conversation moved between groups");
+  return updated;
+});

package/dist/runtime/server/api/conversations/groups/[groupId]/index.delete.d.ts

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<{
+    success: boolean;
+}>>;
+export default _default;

package/dist/runtime/server/api/conversations/groups/[groupId]/index.delete.js

@@ -0,0 +1,25 @@
+import { createError, defineEventHandler, getRouterParam } from "h3";
+import { useDb, schema } from "#chat-runtime/server/db";
+import { resolveChatRuntimeContext } from "#chat-runtime/server/utils/chat-context";
+import { conversationGroupScopeConditions } from "#chat-runtime/server/utils/conversation-group";
+import { logger } from "#chat-runtime/server/utils/logger";
+export default defineEventHandler(async (event) => {
+  const context = resolveChatRuntimeContext(event);
+  const db = useDb();
+  const groupId = getRouterParam(event, "groupId");
+  if (!groupId) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Group ID is required"
+    });
+  }
+  const [group] = await db.delete(schema.conversationGroups).where(conversationGroupScopeConditions(context, groupId)).returning();
+  if (!group) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Conversation group not found"
+    });
+  }
+  logger.info({ groupId, workspaceId: context.workspaceId }, "Conversation group deleted");
+  return { success: true };
+});

package/dist/runtime/server/api/conversations/groups/[groupId]/index.patch.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/conversations/groups/[groupId]/index.patch.js

@@ -0,0 +1,30 @@
+import { createError, defineEventHandler, getRouterParam, readBody } from "h3";
+import { useDb, schema } from "#chat-runtime/server/db";
+import { resolveChatRuntimeContext } from "#chat-runtime/server/utils/chat-context";
+import { conversationGroupScopeConditions, resolveConversationGroupName } from "#chat-runtime/server/utils/conversation-group";
+import { logger } from "#chat-runtime/server/utils/logger";
+export default defineEventHandler(async (event) => {
+  const context = resolveChatRuntimeContext(event);
+  const db = useDb();
+  const groupId = getRouterParam(event, "groupId");
+  if (!groupId) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Group ID is required"
+    });
+  }
+  const body = await readBody(event);
+  const name = resolveConversationGroupName(body?.name);
+  const [group] = await db.update(schema.conversationGroups).set({
+    name,
+    updatedAt: /* @__PURE__ */ new Date()
+  }).where(conversationGroupScopeConditions(context, groupId)).returning();
+  if (!group) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Conversation group not found"
+    });
+  }
+  logger.info({ groupId, workspaceId: context.workspaceId }, "Conversation group renamed");
+  return group;
+});

package/dist/runtime/server/api/conversations/groups/index.get.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/conversations/groups/index.get.js

@@ -0,0 +1,13 @@
+import { defineEventHandler } from "h3";
+import { asc } from "drizzle-orm";
+import { useDb, schema } from "#chat-runtime/server/db";
+import { resolveChatRuntimeContext } from "#chat-runtime/server/utils/chat-context";
+import { conversationGroupScopeConditions } from "#chat-runtime/server/utils/conversation-group";
+import { logger } from "#chat-runtime/server/utils/logger";
+export default defineEventHandler(async (event) => {
+  const context = resolveChatRuntimeContext(event);
+  const db = useDb();
+  const groups = await db.select().from(schema.conversationGroups).where(conversationGroupScopeConditions(context)).orderBy(asc(schema.conversationGroups.createdAt), asc(schema.conversationGroups.name));
+  logger.debug({ workspaceId: context.workspaceId, count: groups.length }, "Conversation groups listed");
+  return groups;
+});

package/dist/runtime/server/api/conversations/groups/index.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/conversations/groups/index.post.js

@@ -0,0 +1,26 @@
+import { createError, defineEventHandler, readBody } from "h3";
+import { useDb, schema } from "#chat-runtime/server/db";
+import { resolveChatRuntimeContext } from "#chat-runtime/server/utils/chat-context";
+import { resolveConversationGroupName } from "#chat-runtime/server/utils/conversation-group";
+import { logger } from "#chat-runtime/server/utils/logger";
+export default defineEventHandler(async (event) => {
+  const context = resolveChatRuntimeContext(event);
+  const db = useDb();
+  const body = await readBody(event);
+  const name = resolveConversationGroupName(body?.name);
+  const [group] = await db.insert(schema.conversationGroups).values({
+    workspaceId: context.workspaceId,
+    telaAgentId: context.telaAgentId,
+    conversationScope: context.conversationScope,
+    name,
+    createdBy: context.user.email
+  }).returning();
+  if (!group) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: "Failed to create conversation group"
+    });
+  }
+  logger.info({ groupId: group.id, workspaceId: context.workspaceId }, "Conversation group created");
+  return group;
+});

package/dist/runtime/server/api/conversations/index.post.js

@@ -27,6 +27,7 @@ export default defineEventHandler(async (event) => {
   }
   const [conversation] = await db.insert(schema.conversations).values({
     workspaceId: context.workspaceId,
+    groupId: null,
     userId: context.user.id,
     createdBy: context.user.email,
     telaAgentId: context.telaAgentId,

package/dist/runtime/server/db/schema/conversation-groups.d.ts

@@ -0,0 +1,143 @@
+export declare const conversationGroups: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "conversation_groups";
+    schema: "chat";
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "conversation_groups";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        workspaceId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "workspace_id";
+            tableName: "conversation_groups";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        telaAgentId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "tela_agent_id";
+            tableName: "conversation_groups";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        conversationScope: import("drizzle-orm/pg-core").PgColumn<{
+            name: "conversation_scope";
+            tableName: "conversation_groups";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        name: import("drizzle-orm/pg-core").PgColumn<{
+            name: "name";
+            tableName: "conversation_groups";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdBy: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_by";
+            tableName: "conversation_groups";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "conversation_groups";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "conversation_groups";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;

package/dist/runtime/server/db/schema/conversation-groups.js

@@ -0,0 +1,20 @@
+import { index, text, timestamp, uuid } from "drizzle-orm/pg-core";
+import { chatSchema } from "./_schema.js";
+export const conversationGroups = chatSchema.table("conversation_groups", {
+  id: uuid("id").primaryKey().defaultRandom(),
+  workspaceId: text("workspace_id").notNull(),
+  telaAgentId: text("tela_agent_id"),
+  conversationScope: text("conversation_scope"),
+  name: text("name").notNull(),
+  createdBy: text("created_by"),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull()
+}, (table) => [
+  index("idx_conversation_groups_workspace").on(table.workspaceId),
+  index("idx_conversation_groups_runtime_created_at").on(
+    table.workspaceId,
+    table.telaAgentId,
+    table.conversationScope,
+    table.createdAt
+  )
+]);

package/dist/runtime/server/db/schema/conversations.d.ts

@@ -37,6 +37,23 @@ export declare const conversations: import("drizzle-orm/pg-core").PgTableWithCol
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        groupId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "group_id";
+            tableName: "conversations";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
         userId: import("drizzle-orm/pg-core").PgColumn<{
             name: "user_id";
             tableName: "conversations";

package/dist/runtime/server/db/schema/conversations.js

@@ -1,8 +1,10 @@
 import { uuid, text, timestamp, index, jsonb } from "drizzle-orm/pg-core";
 import { chatSchema } from "./_schema.js";
+import { conversationGroups } from "./conversation-groups.js";
 export const conversations = chatSchema.table("conversations", {
   id: uuid("id").primaryKey().defaultRandom(),
   workspaceId: text("workspace_id").notNull(),
+  groupId: uuid("group_id").references(() => conversationGroups.id, { onDelete: "set null" }),
   userId: text("user_id").notNull(),
   title: text("title").notNull().default("Nova conversa"),
   threadSessionId: text("thread_session_id"),
@@ -16,6 +18,7 @@ export const conversations = chatSchema.table("conversations", {
   updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull()
 }, (table) => [
   index("idx_conversations_workspace").on(table.workspaceId),
+  index("idx_conversations_group").on(table.groupId),
   index("idx_conversations_user").on(table.userId),
   index("idx_conversations_updated").on(table.updatedAt),
   index("idx_conversations_workspace_tela_agent_updated").on(table.workspaceId, table.telaAgentId, table.updatedAt)

package/dist/runtime/server/db/schema/index.d.ts

@@ -1,4 +1,5 @@
 export { CHAT_SCHEMA_NAME, chatSchema } from './_schema.js';
+export { conversationGroups } from './conversation-groups.js';
 export { conversationUsage, type ConversationUsageMetadata, type ModelUsageEntry } from './conversation-usage.js';
 export { conversations } from './conversations.js';
 export { type ExternalSkillInsert, type ExternalSkillRow, externalSkills, externalSkillsRelations } from './external-skills.js';

package/dist/runtime/server/db/schema/index.js

@@ -1,4 +1,5 @@
 export { CHAT_SCHEMA_NAME, chatSchema } from "./_schema.js";
+export { conversationGroups } from "./conversation-groups.js";
 export { conversationUsage } from "./conversation-usage.js";
 export { conversations } from "./conversations.js";
 export { externalSkills, externalSkillsRelations } from "./external-skills.js";

package/dist/runtime/server/utils/conversation-group.d.ts

@@ -0,0 +1,4 @@
+import type { ChatRuntimeContext } from '#chat-runtime/server/utils/chat-context';
+export declare function conversationGroupScopeConditions(context: ChatRuntimeContext, groupId?: string): import("drizzle-orm").SQL<unknown> | undefined;
+export declare function resolveConversationGroupName(name: unknown): string;
+export declare function resolveOptionalConversationGroupId(groupId: unknown): string | null;

package/dist/runtime/server/utils/conversation-group.js

@@ -0,0 +1,48 @@
+import { and, eq, isNull } from "drizzle-orm";
+import { createError } from "h3";
+import { schema } from "#chat-runtime/server/db";
+const MAX_GROUP_NAME_LENGTH = 80;
+export function conversationGroupScopeConditions(context, groupId) {
+  const conditions = [
+    eq(schema.conversationGroups.workspaceId, context.workspaceId),
+    context.telaAgentId ? eq(schema.conversationGroups.telaAgentId, context.telaAgentId) : isNull(schema.conversationGroups.telaAgentId),
+    context.conversationScope ? eq(schema.conversationGroups.conversationScope, context.conversationScope) : isNull(schema.conversationGroups.conversationScope)
+  ];
+  if (groupId) {
+    conditions.unshift(eq(schema.conversationGroups.id, groupId));
+  }
+  return and(...conditions);
+}
+export function resolveConversationGroupName(name) {
+  if (typeof name !== "string") {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Group name is required"
+    });
+  }
+  const trimmedName = name.trim();
+  if (!trimmedName) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Group name cannot be empty"
+    });
+  }
+  if (trimmedName.length > MAX_GROUP_NAME_LENGTH) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Group name is too long"
+    });
+  }
+  return trimmedName;
+}
+export function resolveOptionalConversationGroupId(groupId) {
+  if (groupId === null)
+    return null;
+  if (typeof groupId !== "string" || !groupId.trim()) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Invalid group ID"
+    });
+  }
+  return groupId.trim();
+}

package/dist/runtime/types/chat.d.ts

@@ -1,9 +1,10 @@
 import type { InferSelectModel } from 'drizzle-orm';
-import type { conversations, messages, ContextFile as SchemaContextFile, ExternalSkill as SchemaExternalSkill, MessageFile as SchemaMessageFile } from '#chat-runtime/server/db/schema';
+import type { conversationGroups, conversations, messages, ContextFile as SchemaContextFile, ExternalSkill as SchemaExternalSkill, MessageFile as SchemaMessageFile } from '#chat-runtime/server/db/schema';
 export type ContextFile = SchemaContextFile;
 export type ExternalSkill = SchemaExternalSkill;
 export type MessageFile = SchemaMessageFile;
 export type Conversation = InferSelectModel<typeof conversations>;
+export type ConversationGroup = InferSelectModel<typeof conversationGroups>;
 export type Message = InferSelectModel<typeof messages>;
 export type ConversationCreatorFilter = 'all' | 'mine';
 export type ConversationCreatorFilterCounts = Record<ConversationCreatorFilter, number>;

package/dist/runtime/utils/conversation-groups.d.ts

@@ -0,0 +1,18 @@
+export type ConversationGroupLike = {
+    id: string;
+    name: string;
+    createdAt?: Date | string;
+};
+export type ConversationGroupItem = {
+    groupId?: string | null;
+    updatedAt: Date | string;
+};
+export type ConversationGroupBucket<TGroup extends ConversationGroupLike, TConversation extends ConversationGroupItem> = {
+    group: TGroup;
+    items: TConversation[];
+};
+export type GroupedConversations<TGroup extends ConversationGroupLike, TConversation extends ConversationGroupItem> = {
+    groups: ConversationGroupBucket<TGroup, TConversation>[];
+    unfiled: TConversation[];
+};
+export declare function groupConversationsByGroup<TConversation extends ConversationGroupItem, TGroup extends ConversationGroupLike>(conversations: readonly TConversation[], groups: readonly TGroup[]): GroupedConversations<TGroup, TConversation>;