@meistrari/chat-nuxt 1.10.0 → 1.12.0

package/dist/runtime/embed/components/configuration/ChatConfigurationContextFilesTab.vue.d.ts

@@ -8,15 +8,15 @@ type __VLS_Props = {
     getFileType: (fileName: string) => string;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
-    "update:searchQuery": (value: string) => any;
     handleFileSelect: (event: Event) => any;
-    removePendingFile: (file: File) => any;
     removeContextFile: (url: string) => any;
+    removePendingFile: (file: File) => any;
+    "update:searchQuery": (value: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    "onUpdate:searchQuery"?: ((value: string) => any) | undefined;
     onHandleFileSelect?: ((event: Event) => any) | undefined;
-    onRemovePendingFile?: ((file: File) => any) | undefined;
     onRemoveContextFile?: ((url: string) => any) | undefined;
+    onRemovePendingFile?: ((file: File) => any) | undefined;
+    "onUpdate:searchQuery"?: ((value: string) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/embed/components/configuration/ChatConfigurationMobileShell.d.vue.ts

@@ -15,13 +15,13 @@ type __VLS_Slots = {} & {
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     close: () => any;
-    back: () => any;
     save: () => any;
+    back: () => any;
     selectTab: (value: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onClose?: (() => any) | undefined;
-    onBack?: (() => any) | undefined;
     onSave?: (() => any) | undefined;
+    onBack?: (() => any) | undefined;
     onSelectTab?: ((value: string) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/runtime/embed/components/configuration/ChatConfigurationMobileShell.vue.d.ts

@@ -15,13 +15,13 @@ type __VLS_Slots = {} & {
 };
 declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
     close: () => any;
-    back: () => any;
     save: () => any;
+    back: () => any;
     selectTab: (value: string) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     onClose?: (() => any) | undefined;
-    onBack?: (() => any) | undefined;
     onSave?: (() => any) | undefined;
+    onBack?: (() => any) | undefined;
     onSelectTab?: ((value: string) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

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/chat/conversations/metadata.get.d.ts

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

package/dist/runtime/server/api/chat/conversations/metadata.get.js

@@ -0,0 +1 @@
+export { default } from "../../conversations/metadata.get.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/api/conversations/metadata.get.d.ts

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

package/dist/runtime/server/api/conversations/metadata.get.js

@@ -0,0 +1,20 @@
+import { defineEventHandler } from "h3";
+import { sql } from "drizzle-orm";
+import { useDb, schema } from "#chat-runtime/server/db";
+import { resolveChatRuntimeContext } from "#chat-runtime/server/utils/chat-context";
+import { conversationScopeConditions } from "#chat-runtime/server/utils/conversation-scope";
+import { logger } from "#chat-runtime/server/utils/logger";
+export default defineEventHandler(async (event) => {
+  const context = resolveChatRuntimeContext(event);
+  const db = useDb();
+  const [metadata] = await db.select({
+    all: sql`COUNT(*)::int`,
+    mine: sql`COUNT(*) FILTER (WHERE ${schema.conversations.userId} = ${context.user.id})::int`
+  }).from(schema.conversations).where(conversationScopeConditions(context));
+  const counts = {
+    all: metadata?.all ?? 0,
+    mine: metadata?.mine ?? 0
+  };
+  logger.debug({ workspaceId: context.workspaceId, counts }, "Conversations metadata loaded");
+  return { counts };
+});

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,11 +1,16 @@
 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>;
+export type ConversationListMetadata = {
+    counts: ConversationCreatorFilterCounts;
+};
 export declare const CONVERSATION_CREATOR_FILTER_OPTIONS: readonly [{
     readonly label: "Todas";
     readonly value: "all";

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>;