devchain-cli 0.1.0

package/dist/server/modules/chat/services/chat.service.js

@@ -0,0 +1,730 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatService = void 0;
+const common_1 = require("@nestjs/common");
+const error_types_1 = require("../../../common/errors/error-types");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const db_provider_1 = require("../../storage/db/db.provider");
+const better_sqlite3_1 = require("drizzle-orm/better-sqlite3");
+const drizzle_orm_1 = require("drizzle-orm");
+const crypto_1 = require("crypto");
+const logger_1 = require("../../../common/logging/logger");
+const schema_1 = require("../../storage/db/schema");
+const chat_settings_service_1 = require("./chat-settings.service");
+const invite_template_util_1 = require("./invite-template.util");
+const sessions_service_1 = require("../../sessions/services/sessions.service");
+const logger = (0, logger_1.createLogger)('ChatService');
+const DEFAULT_INVITER_NAME = 'You';
+let ChatService = class ChatService {
+    constructor(db, eventEmitter, chatSettingsService, sessionsService) {
+        this.db = db;
+        this.eventEmitter = eventEmitter;
+        this.chatSettingsService = chatSettingsService;
+        this.sessionsService = sessionsService;
+        logger.info('ChatService initialized');
+    }
+    deriveThreadTitle(thread, participantNames) {
+        if (thread.title && thread.title.trim().length > 0) {
+            return thread.title;
+        }
+        return participantNames || 'Chat Thread';
+    }
+    async sendInviteMessage(threadId, projectId, agentName, threadTitle, participantNames, inviterName = DEFAULT_INVITER_NAME) {
+        const inviteTemplate = await this.chatSettingsService.getInviteTemplate(projectId);
+        const inviteMessageId = (0, crypto_1.randomUUID)();
+        const messageTimestamp = new Date().toISOString();
+        const renderedTemplate = (0, invite_template_util_1.renderInviteTemplate)(inviteTemplate, {
+            threadId,
+            threadTitle,
+            inviterName,
+            participantNames,
+            invitedAgentName: agentName,
+            createdAt: messageTimestamp,
+            messageId: inviteMessageId,
+        });
+        await this.persistMessage(threadId, {
+            messageId: inviteMessageId,
+            authorType: 'system',
+            content: renderedTemplate,
+            createdAt: messageTimestamp,
+        });
+    }
+    async persistMessage(threadId, data) {
+        const createdAt = data.createdAt ?? new Date().toISOString();
+        const messageId = data.messageId ?? (0, crypto_1.randomUUID)();
+        const effectiveTargets = data.authorType === 'user' && data.targets && data.targets.length > 0 ? data.targets : [];
+        await this.db.insert(schema_1.chatMessages).values({
+            id: messageId,
+            threadId,
+            authorType: data.authorType,
+            authorAgentId: data.authorAgentId ?? null,
+            content: data.content,
+            createdAt,
+        });
+        if (effectiveTargets.length > 0) {
+            const targetValues = effectiveTargets.map((agentId) => ({
+                id: (0, crypto_1.randomUUID)(),
+                messageId,
+                agentId,
+                createdAt,
+            }));
+            await this.db.insert(schema_1.chatMessageTargets).values(targetValues);
+        }
+        await this.db
+            .update(schema_1.chatThreads)
+            .set({ updatedAt: createdAt })
+            .where((0, drizzle_orm_1.eq)(schema_1.chatThreads.id, threadId));
+        const message = {
+            id: messageId,
+            threadId,
+            authorType: data.authorType,
+            authorAgentId: data.authorAgentId ?? null,
+            content: data.content,
+            targets: effectiveTargets.length > 0 ? effectiveTargets : undefined,
+            createdAt,
+        };
+        try {
+            this.eventEmitter.emit('chat.message.created', {
+                threadId,
+                message,
+            });
+        }
+        catch (error) {
+            logger.warn({ error, threadId, messageId }, 'Failed to emit chat.message.created event');
+        }
+        return message;
+    }
+    async listThreads(query) {
+        const { projectId, createdByType, limit, offset } = query;
+        const conditions = [(0, drizzle_orm_1.eq)(schema_1.chatThreads.projectId, projectId)];
+        if (createdByType) {
+            conditions.push((0, drizzle_orm_1.eq)(schema_1.chatThreads.createdByType, createdByType));
+        }
+        const whereClause = (0, drizzle_orm_1.and)(...conditions);
+        const threads = await this.db
+            .select()
+            .from(schema_1.chatThreads)
+            .where(whereClause)
+            .orderBy((0, drizzle_orm_1.desc)(schema_1.chatThreads.updatedAt))
+            .limit(limit)
+            .offset(offset);
+        const countResult = await this.db
+            .select({ count: schema_1.chatThreads.id })
+            .from(schema_1.chatThreads)
+            .where(whereClause);
+        const total = countResult.length;
+        const threadIds = threads.map((t) => t.id);
+        const membersRows = threadIds.length > 0
+            ? await this.db.select().from(schema_1.chatMembers).where((0, drizzle_orm_1.inArray)(schema_1.chatMembers.threadId, threadIds))
+            : [];
+        const membersByThread = new Map();
+        for (const row of membersRows) {
+            if (!membersByThread.has(row.threadId)) {
+                membersByThread.set(row.threadId, []);
+            }
+            membersByThread.get(row.threadId).push(row.agentId);
+        }
+        const items = threads.map((thread) => ({
+            id: thread.id,
+            projectId: thread.projectId,
+            title: thread.title,
+            isGroup: thread.isGroup,
+            createdByType: thread.createdByType,
+            createdByUserId: thread.createdByUserId,
+            createdByAgentId: thread.createdByAgentId,
+            members: membersByThread.get(thread.id) ?? [],
+            createdAt: thread.createdAt,
+            updatedAt: thread.updatedAt,
+        }));
+        return {
+            items,
+            total,
+            limit,
+            offset,
+        };
+    }
+    async getThread(threadId) {
+        const thread = await this.db
+            .select()
+            .from(schema_1.chatThreads)
+            .where((0, drizzle_orm_1.eq)(schema_1.chatThreads.id, threadId))
+            .limit(1);
+        if (thread.length === 0) {
+            throw new common_1.NotFoundException(`Thread ${threadId} not found`);
+        }
+        const members = await this.db
+            .select()
+            .from(schema_1.chatMembers)
+            .where((0, drizzle_orm_1.eq)(schema_1.chatMembers.threadId, threadId));
+        return {
+            id: thread[0].id,
+            projectId: thread[0].projectId,
+            title: thread[0].title,
+            isGroup: thread[0].isGroup,
+            createdByType: thread[0].createdByType,
+            createdByUserId: thread[0].createdByUserId,
+            createdByAgentId: thread[0].createdByAgentId,
+            members: members.map((m) => m.agentId),
+            createdAt: thread[0].createdAt,
+            updatedAt: thread[0].updatedAt,
+        };
+    }
+    async createDirectThread(data) {
+        const now = new Date().toISOString();
+        const threadId = (0, crypto_1.randomUUID)();
+        const existingThreads = await this.db
+            .select()
+            .from(schema_1.chatThreads)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.chatThreads.projectId, data.projectId), (0, drizzle_orm_1.eq)(schema_1.chatThreads.isGroup, false), (0, drizzle_orm_1.eq)(schema_1.chatThreads.createdByType, 'user')));
+        for (const thread of existingThreads) {
+            const members = await this.db
+                .select()
+                .from(schema_1.chatMembers)
+                .where((0, drizzle_orm_1.eq)(schema_1.chatMembers.threadId, thread.id));
+            if (members.length === 1 && members[0].agentId === data.agentId) {
+                return this.getThread(thread.id);
+            }
+        }
+        await this.db.insert(schema_1.chatThreads).values({
+            id: threadId,
+            projectId: data.projectId,
+            title: null,
+            isGroup: false,
+            createdByType: 'user',
+            createdByUserId: null,
+            createdByAgentId: null,
+            createdAt: now,
+            updatedAt: now,
+        });
+        await this.db.insert(schema_1.chatMembers).values({
+            threadId,
+            agentId: data.agentId,
+            createdAt: now,
+        });
+        const agentRow = await this.db
+            .select({
+            id: schema_1.agents.id,
+            name: schema_1.agents.name,
+        })
+            .from(schema_1.agents)
+            .where((0, drizzle_orm_1.eq)(schema_1.agents.id, data.agentId))
+            .limit(1);
+        if (agentRow.length > 0) {
+            const agent = agentRow[0];
+            await this.sendInviteMessage(threadId, data.projectId, agent.name, agent.name, agent.name);
+        }
+        logger.info({ threadId, agentId: data.agentId }, 'Created direct thread');
+        return this.getThread(threadId);
+    }
+    async createGroupThread(data) {
+        const now = new Date().toISOString();
+        const threadId = (0, crypto_1.randomUUID)();
+        if (data.agentIds.length < 2) {
+            throw new error_types_1.ValidationError('Group threads require at least 2 agents', {
+                provided: data.agentIds.length,
+                required: 2,
+            });
+        }
+        await this.db.insert(schema_1.chatThreads).values({
+            id: threadId,
+            projectId: data.projectId,
+            title: data.title ?? null,
+            isGroup: true,
+            createdByType: data.createdByType ?? 'user',
+            createdByUserId: null,
+            createdByAgentId: data.createdByAgentId ?? null,
+            createdAt: now,
+            updatedAt: now,
+        });
+        const memberValues = data.agentIds.map((agentId) => ({
+            threadId,
+            agentId,
+            createdAt: now,
+        }));
+        await this.db.insert(schema_1.chatMembers).values(memberValues);
+        logger.info({ threadId, agentIds: data.agentIds, title: data.title }, 'Created group thread');
+        return this.getThread(threadId);
+    }
+    async inviteMembers(threadId, data) {
+        const thread = await this.getThread(threadId);
+        if (data.projectId && thread.projectId !== data.projectId) {
+            throw new error_types_1.ValidationError('Thread does not belong to the specified project', {
+                threadId,
+                threadProjectId: thread.projectId,
+                requestedProjectId: data.projectId,
+            });
+        }
+        if (!thread.isGroup || thread.createdByType !== 'user') {
+            throw new error_types_1.ValidationError('Invites are only supported for user-created group threads', {
+                threadId,
+                isGroup: thread.isGroup,
+                createdByType: thread.createdByType,
+            });
+        }
+        const uniqueAgentIds = Array.from(new Set(data.agentIds));
+        if (uniqueAgentIds.length === 0) {
+            throw new error_types_1.ValidationError('At least one agent must be specified for invitation', {
+                threadId,
+            });
+        }
+        const existingMembers = new Set(thread.members ?? []);
+        const agentIdsToAdd = uniqueAgentIds.filter((agentId) => !existingMembers.has(agentId));
+        if (agentIdsToAdd.length === 0) {
+            throw new error_types_1.ValidationError('All selected agents are already participants in this thread', {
+                threadId,
+                requestedAgents: uniqueAgentIds,
+            });
+        }
+        const inviterName = data.inviterName?.trim().length
+            ? data.inviterName.trim()
+            : DEFAULT_INVITER_NAME;
+        const memberIdsToFetch = Array.from(new Set([...existingMembers, ...agentIdsToAdd]));
+        const agentRows = memberIdsToFetch.length > 0
+            ? await this.db
+                .select({
+                id: schema_1.agents.id,
+                projectId: schema_1.agents.projectId,
+                name: schema_1.agents.name,
+            })
+                .from(schema_1.agents)
+                .where((0, drizzle_orm_1.inArray)(schema_1.agents.id, memberIdsToFetch))
+            : [];
+        const agentMap = new Map(agentRows.map((row) => [row.id, row]));
+        const missingAgents = agentIdsToAdd.filter((agentId) => !agentMap.has(agentId));
+        if (missingAgents.length > 0) {
+            throw new error_types_1.ValidationError(`Agents not found: ${missingAgents
+                .map((id) => id.slice(0, 8))
+                .join(', ')}. Please verify the selection.`, {
+                threadId,
+                missingAgents,
+            });
+        }
+        const crossProjectAgents = agentIdsToAdd.filter((agentId) => agentMap.get(agentId).projectId !== thread.projectId);
+        if (crossProjectAgents.length > 0) {
+            throw new error_types_1.ValidationError('One or more selected agents belong to a different project and cannot be invited.', {
+                threadId,
+                threadProjectId: thread.projectId,
+                crossProjectAgents,
+            });
+        }
+        const membershipInsertedAt = new Date().toISOString();
+        await this.db.insert(schema_1.chatMembers).values(agentIdsToAdd.map((agentId) => ({
+            threadId,
+            agentId,
+            createdAt: membershipInsertedAt,
+        })));
+        agentIdsToAdd.forEach((agentId) => existingMembers.add(agentId));
+        const participantNamesList = Array.from(existingMembers)
+            .map((agentId) => agentMap.get(agentId)?.name)
+            .filter((name) => Boolean(name))
+            .sort((a, b) => a.localeCompare(b));
+        const participantNames = participantNamesList.length > 0
+            ? participantNamesList.join(', ')
+            : 'Participants unavailable';
+        const threadTitle = this.deriveThreadTitle(thread, participantNames);
+        for (const agentId of agentIdsToAdd) {
+            const invitedAgent = agentMap.get(agentId);
+            const messageTimestamp = new Date().toISOString();
+            await this.persistMessage(threadId, {
+                authorType: 'system',
+                content: `You invited ${invitedAgent.name}.`,
+                createdAt: messageTimestamp,
+            });
+            await this.sendInviteMessage(threadId, thread.projectId, invitedAgent.name, threadTitle, participantNames, inviterName);
+        }
+        logger.info({ threadId, invitedAgents: agentIdsToAdd, inviterName }, 'Invited agents to chat thread');
+        return this.getThread(threadId);
+    }
+    async listAgentInitiatedThreads(query) {
+        return this.listThreads({
+            ...query,
+            createdByType: 'agent',
+        });
+    }
+    async listMessages(threadId, query) {
+        let { since } = query;
+        const { limit, offset } = query;
+        const threadRows = await this.db
+            .select()
+            .from(schema_1.chatThreads)
+            .where((0, drizzle_orm_1.eq)(schema_1.chatThreads.id, threadId))
+            .limit(1);
+        if (!since && threadRows.length > 0 && threadRows[0].lastUserClearedAt) {
+            since = threadRows[0].lastUserClearedAt;
+            logger.debug({ threadId, defaultSince: since }, 'Using lastUserClearedAt as default since filter');
+        }
+        const conditions = [(0, drizzle_orm_1.eq)(schema_1.chatMessages.threadId, threadId)];
+        if (since) {
+            conditions.push((0, drizzle_orm_1.gt)(schema_1.chatMessages.createdAt, since));
+        }
+        const whereClause = (0, drizzle_orm_1.and)(...conditions);
+        const messages = await this.db
+            .select()
+            .from(schema_1.chatMessages)
+            .where(whereClause)
+            .orderBy(schema_1.chatMessages.createdAt)
+            .limit(limit)
+            .offset(offset);
+        const countResult = await this.db
+            .select({ count: schema_1.chatMessages.id })
+            .from(schema_1.chatMessages)
+            .where(whereClause);
+        const total = countResult.length;
+        const messageIds = messages.map((m) => m.id);
+        const targetsRows = messageIds.length > 0
+            ? await this.db
+                .select()
+                .from(schema_1.chatMessageTargets)
+                .where((0, drizzle_orm_1.inArray)(schema_1.chatMessageTargets.messageId, messageIds))
+            : [];
+        const targetsByMessage = new Map();
+        for (const row of targetsRows) {
+            if (!targetsByMessage.has(row.messageId)) {
+                targetsByMessage.set(row.messageId, []);
+            }
+            targetsByMessage.get(row.messageId).push(row.agentId);
+        }
+        const items = messages.map((message) => ({
+            id: message.id,
+            threadId: message.threadId,
+            authorType: message.authorType,
+            authorAgentId: message.authorAgentId,
+            content: message.content,
+            targets: targetsByMessage.get(message.id),
+            createdAt: message.createdAt,
+        }));
+        return {
+            items,
+            total,
+            limit,
+            offset,
+        };
+    }
+    async ensureSessionInvites(threadId, projectId, targetedAgentIds) {
+        if (targetedAgentIds.length === 0) {
+            return;
+        }
+        const activeSessions = await this.sessionsService.listActiveSessions(projectId);
+        const sessionsByAgent = new Map();
+        for (const session of activeSessions) {
+            if (session.agentId && session.tmuxSessionId) {
+                sessionsByAgent.set(session.agentId, session.tmuxSessionId);
+            }
+        }
+        for (const agentId of targetedAgentIds) {
+            const sessionId = sessionsByAgent.get(agentId);
+            if (!sessionId) {
+                continue;
+            }
+            const existingInvites = await this.db
+                .select()
+                .from(schema_1.chatThreadSessionInvites)
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.chatThreadSessionInvites.threadId, threadId), (0, drizzle_orm_1.eq)(schema_1.chatThreadSessionInvites.agentId, agentId), (0, drizzle_orm_1.eq)(schema_1.chatThreadSessionInvites.sessionId, sessionId)))
+                .limit(1);
+            if (existingInvites.length > 0) {
+                logger.debug({ threadId, agentId, sessionId }, 'Invite already exists for this session, skipping');
+                continue;
+            }
+            const agentRows = await this.db
+                .select({ name: schema_1.agents.name })
+                .from(schema_1.agents)
+                .where((0, drizzle_orm_1.eq)(schema_1.agents.id, agentId))
+                .limit(1);
+            if (agentRows.length === 0) {
+                logger.warn({ agentId }, 'Agent not found, skipping invite');
+                continue;
+            }
+            const agentName = agentRows[0].name;
+            const threadRows = await this.db
+                .select()
+                .from(schema_1.chatThreads)
+                .where((0, drizzle_orm_1.eq)(schema_1.chatThreads.id, threadId))
+                .limit(1);
+            if (threadRows.length === 0) {
+                logger.warn({ threadId }, 'Thread not found during invite creation');
+                continue;
+            }
+            const membersRows = await this.db
+                .select()
+                .from(schema_1.chatMembers)
+                .where((0, drizzle_orm_1.eq)(schema_1.chatMembers.threadId, threadId));
+            const memberAgentIds = membersRows.map((m) => m.agentId);
+            const memberAgents = await this.db
+                .select({ id: schema_1.agents.id, name: schema_1.agents.name })
+                .from(schema_1.agents)
+                .where((0, drizzle_orm_1.inArray)(schema_1.agents.id, memberAgentIds));
+            const participantNames = memberAgents
+                .map((a) => a.name)
+                .sort()
+                .join(', ');
+            const threadTitle = this.deriveThreadTitle({ ...threadRows[0], members: memberAgentIds }, participantNames);
+            const inviteTemplate = await this.chatSettingsService.getInviteTemplate(projectId);
+            const inviteMessageId = (0, crypto_1.randomUUID)();
+            const messageTimestamp = new Date().toISOString();
+            const renderedTemplate = (0, invite_template_util_1.renderInviteTemplate)(inviteTemplate, {
+                threadId,
+                threadTitle,
+                inviterName: DEFAULT_INVITER_NAME,
+                participantNames,
+                invitedAgentName: agentName,
+                createdAt: messageTimestamp,
+                messageId: inviteMessageId,
+            });
+            try {
+                await this.persistMessage(threadId, {
+                    messageId: inviteMessageId,
+                    authorType: 'system',
+                    content: renderedTemplate,
+                    createdAt: messageTimestamp,
+                });
+                await this.db.insert(schema_1.chatThreadSessionInvites).values({
+                    id: (0, crypto_1.randomUUID)(),
+                    threadId,
+                    agentId,
+                    sessionId,
+                    inviteMessageId,
+                    sentAt: messageTimestamp,
+                    acknowledgedAt: null,
+                });
+                logger.info({ threadId, agentId, sessionId, inviteMessageId }, 'Sent session-aware invite');
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes('UNIQUE constraint')) {
+                    logger.debug({ threadId, agentId, sessionId }, 'Invite already exists (race condition), continuing');
+                }
+                else {
+                    logger.error({ error, threadId, agentId, sessionId }, 'Failed to create session invite');
+                    throw error;
+                }
+            }
+        }
+    }
+    async createMessage(threadId, data) {
+        const thread = await this.getThread(threadId);
+        if (data.projectId && thread.projectId !== data.projectId) {
+            throw new error_types_1.ValidationError('Thread does not belong to the specified project', {
+                threadId,
+                threadProjectId: thread.projectId,
+                requestedProjectId: data.projectId,
+            });
+        }
+        if (data.authorType === 'system') {
+            throw new error_types_1.ValidationError('System messages cannot be posted via the public API', {
+                threadId,
+                authorType: data.authorType,
+            });
+        }
+        logger.info({
+            threadId,
+            authorType: data.authorType,
+            hasTargets: Boolean(data.targets && data.targets.length > 0),
+        }, 'Creating chat message');
+        const targetedAgentIds = data.authorType === 'user' && data.targets && data.targets.length > 0
+            ? data.targets
+            : (thread.members ?? []);
+        await this.ensureSessionInvites(threadId, thread.projectId, targetedAgentIds);
+        return this.persistMessage(threadId, data);
+    }
+    async clearHistory(threadId, data) {
+        await this.getThread(threadId);
+        const now = new Date().toISOString();
+        await this.db
+            .update(schema_1.chatThreads)
+            .set({ lastUserClearedAt: now, updatedAt: now })
+            .where((0, drizzle_orm_1.eq)(schema_1.chatThreads.id, threadId));
+        if (data.announce) {
+            await this.persistMessage(threadId, {
+                authorType: 'system',
+                content: 'History cleared.',
+                createdAt: now,
+            });
+        }
+        logger.info({ threadId, announce: data.announce }, 'Cleared thread history');
+        return this.getThread(threadId);
+    }
+    async purgeHistory(threadId, data) {
+        await this.getThread(threadId);
+        const cutoff = data.before ?? new Date().toISOString();
+        const idsToDelete = (await this.db
+            .select({ id: schema_1.chatMessages.id })
+            .from(schema_1.chatMessages)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.chatMessages.threadId, threadId), (await Promise.resolve().then(() => __importStar(require('drizzle-orm')))).lt(schema_1.chatMessages.createdAt, cutoff)))).map((r) => r.id);
+        if (idsToDelete.length > 0) {
+            const { lt } = await Promise.resolve().then(() => __importStar(require('drizzle-orm')));
+            await this.db
+                .delete(schema_1.chatMessages)
+                .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.chatMessages.threadId, threadId), lt(schema_1.chatMessages.createdAt, cutoff)));
+            logger.info({ threadId, cutoff, deletedCount: idsToDelete.length }, 'Purged chat messages');
+        }
+        else {
+            logger.info({ threadId, cutoff, deletedCount: 0 }, 'No chat messages to purge');
+        }
+        if (data.announce) {
+            await this.persistMessage(threadId, {
+                authorType: 'system',
+                content: `History purged up to ${cutoff}.`,
+            });
+        }
+        return this.getThread(threadId);
+    }
+    async acknowledgeInvite(threadId, messageId, agentId, sessionId) {
+        const now = new Date().toISOString();
+        const inviteRows = await this.db
+            .select()
+            .from(schema_1.chatThreadSessionInvites)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.chatThreadSessionInvites.threadId, threadId), (0, drizzle_orm_1.eq)(schema_1.chatThreadSessionInvites.agentId, agentId), (0, drizzle_orm_1.eq)(schema_1.chatThreadSessionInvites.sessionId, sessionId), (0, drizzle_orm_1.eq)(schema_1.chatThreadSessionInvites.inviteMessageId, messageId)))
+            .limit(1);
+        if (inviteRows.length === 0) {
+            logger.debug({ threadId, messageId, agentId, sessionId }, 'Message is not an invite');
+            return;
+        }
+        const invite = inviteRows[0];
+        if (!invite.acknowledgedAt) {
+            await this.db
+                .update(schema_1.chatThreadSessionInvites)
+                .set({ acknowledgedAt: now })
+                .where((0, drizzle_orm_1.eq)(schema_1.chatThreadSessionInvites.id, invite.id));
+            logger.info({ threadId, messageId, agentId, sessionId, inviteId: invite.id }, 'Acknowledged invite message');
+        }
+        else {
+            logger.debug({ threadId, messageId, agentId, sessionId }, 'Invite already acknowledged');
+        }
+    }
+    async startActivity(threadId, agentId, title, options) {
+        const announce = options?.announce !== false;
+        const now = new Date().toISOString();
+        let autoFinishedPrior = false;
+        const latest = await this.db
+            .select()
+            .from(schema_1.chatActivities)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.chatActivities.threadId, threadId), (0, drizzle_orm_1.eq)(schema_1.chatActivities.agentId, agentId)))
+            .orderBy((0, drizzle_orm_1.desc)(schema_1.chatActivities.startedAt))
+            .limit(1);
+        if (latest.length > 0 && latest[0].status === 'running') {
+            await this.db
+                .update(schema_1.chatActivities)
+                .set({ status: 'auto_finished', finishedAt: now })
+                .where((0, drizzle_orm_1.eq)(schema_1.chatActivities.id, latest[0].id));
+            autoFinishedPrior = true;
+        }
+        const startContent = `${title}`;
+        let startMessageId = null;
+        if (announce) {
+            const startMessage = await this.persistMessage(threadId, {
+                authorType: 'system',
+                content: startContent,
+            });
+            startMessageId = startMessage.id;
+        }
+        const activityId = (0, crypto_1.randomUUID)();
+        await this.db.insert(schema_1.chatActivities).values({
+            id: activityId,
+            threadId,
+            agentId,
+            title,
+            status: 'running',
+            startedAt: now,
+            finishedAt: null,
+            startMessageId,
+            finishMessageId: null,
+        });
+        return {
+            activityId,
+            startMessageId,
+            startedAt: now,
+            autoFinishedPrior,
+        };
+    }
+    async finishActivity(threadId, agentId, options) {
+        const now = new Date().toISOString();
+        const running = await this.db
+            .select()
+            .from(schema_1.chatActivities)
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_1.chatActivities.threadId, threadId), (0, drizzle_orm_1.eq)(schema_1.chatActivities.agentId, agentId), (0, drizzle_orm_1.eq)(schema_1.chatActivities.status, 'running')))
+            .orderBy((0, drizzle_orm_1.desc)(schema_1.chatActivities.startedAt))
+            .limit(1);
+        if (running.length === 0) {
+            throw new error_types_1.ValidationError('No running activity to finish', {
+                threadId,
+                agentId,
+            });
+        }
+        const current = running[0];
+        const status = options?.status ?? 'success';
+        let finishMessageId = null;
+        if (options?.message && options.message.trim().length > 0) {
+            const finishMessage = await this.persistMessage(threadId, {
+                authorType: 'system',
+                content: options.message,
+            });
+            finishMessageId = finishMessage.id;
+        }
+        await this.db
+            .update(schema_1.chatActivities)
+            .set({ status, finishedAt: now, finishMessageId })
+            .where((0, drizzle_orm_1.eq)(schema_1.chatActivities.id, current.id));
+        return {
+            activityId: current.id,
+            finishMessageId,
+            startedAt: current.startedAt,
+            finishedAt: now,
+            status,
+        };
+    }
+};
+exports.ChatService = ChatService;
+exports.ChatService = ChatService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(db_provider_1.DB_CONNECTION)),
+    __param(3, (0, common_1.Inject)((0, common_1.forwardRef)(() => sessions_service_1.SessionsService))),
+    __metadata("design:paramtypes", [better_sqlite3_1.BetterSQLite3Database,
+        event_emitter_1.EventEmitter2,
+        chat_settings_service_1.ChatSettingsService,
+        sessions_service_1.SessionsService])
+], ChatService);
+//# sourceMappingURL=chat.service.js.map