@taico/taico 0.0.2

package/dist/tasks/tasks.service.js

@@ -0,0 +1,831 @@
+"use strict";
+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 __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); }
+};
+var TasksService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TasksService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const typeorm_2 = require("typeorm");
+const task_entity_1 = require("./task.entity");
+const enums_1 = require("./enums");
+const comment_entity_1 = require("./comment.entity");
+const input_request_entity_1 = require("./input-request.entity");
+const actor_entity_1 = require("../identity-provider/actor.entity");
+const tasks_errors_1 = require("./errors/tasks.errors");
+const tasks_events_1 = require("./events/tasks.events");
+const meta_service_1 = require("../meta/meta.service");
+const actor_service_1 = require("../identity-provider/actor.service");
+const search_service_1 = require("../search/search.service");
+const agent_runs_service_1 = require("../agent-runs/agent-runs.service");
+const threads_service_1 = require("../threads/threads.service");
+let TasksService = TasksService_1 = class TasksService {
+    taskRepository;
+    commentRepository;
+    inputRequestRepository;
+    actorRepository;
+    actorService;
+    metaService;
+    eventEmitter;
+    searchService;
+    agentRunsService;
+    threadsService;
+    logger = new common_1.Logger(TasksService_1.name);
+    constructor(taskRepository, commentRepository, inputRequestRepository, actorRepository, actorService, metaService, eventEmitter, searchService, agentRunsService, threadsService) {
+        this.taskRepository = taskRepository;
+        this.commentRepository = commentRepository;
+        this.inputRequestRepository = inputRequestRepository;
+        this.actorRepository = actorRepository;
+        this.actorService = actorService;
+        this.metaService = metaService;
+        this.eventEmitter = eventEmitter;
+        this.searchService = searchService;
+        this.agentRunsService = agentRunsService;
+        this.threadsService = threadsService;
+    }
+    async createTask(input) {
+        this.logger.log({
+            message: 'Creating task',
+            name: input.name,
+            assigneeActorId: input.assigneeActorId,
+            sessionId: input.sessionId,
+        });
+        let assigneeActorId = null;
+        if (input.assigneeActorId) {
+            const assigneeActor = await this.actorService.getActorByIdOrSlug(input.assigneeActorId);
+            if (!assigneeActor) {
+                throw new Error(`Assignee actor not found: ${input.assigneeActorId}`);
+            }
+            assigneeActorId = assigneeActor.id;
+        }
+        const createdByActor = await this.actorService.getActorByIdOrSlug(input.createdByActorId);
+        if (!createdByActor) {
+            throw new Error(`Creator actor not found: ${input.createdByActorId}`);
+        }
+        const createdByActorId = createdByActor.id;
+        const task = this.taskRepository.create({
+            name: input.name,
+            description: input.description,
+            assigneeActorId,
+            sessionId: input.sessionId ?? null,
+            status: enums_1.TaskStatus.NOT_STARTED,
+            createdByActorId,
+        });
+        const savedTask = await this.taskRepository.save(task);
+        if (input.tagNames && input.tagNames.length > 0) {
+            const tags = await this.metaService.findOrCreateTagEntities(input.tagNames);
+            savedTask.tags = tags;
+            await this.taskRepository.save(savedTask);
+        }
+        if (input.dependsOnIds && input.dependsOnIds.length > 0) {
+            const dependencyTasks = await this.taskRepository.findBy({
+                id: (0, typeorm_2.In)(input.dependsOnIds),
+            });
+            if (dependencyTasks.length !== input.dependsOnIds.length) {
+                throw new Error('One or more dependency tasks not found');
+            }
+            savedTask.dependsOn = dependencyTasks;
+            await this.taskRepository.save(savedTask);
+        }
+        const taskWithRelations = await this.taskRepository.findOne({
+            where: { id: savedTask.id },
+            relations: [
+                'comments',
+                'comments.commenterActor',
+                'inputRequests',
+                'tags',
+                'dependsOn',
+                'assigneeActor',
+                'createdByActor',
+            ],
+        });
+        if (!taskWithRelations) {
+            throw new tasks_errors_1.TaskNotFoundError(savedTask.id);
+        }
+        this.logger.log({
+            message: 'Task created',
+            taskId: taskWithRelations.id,
+            name: taskWithRelations.name,
+        });
+        this.eventEmitter.emit(tasks_events_1.TaskCreatedEvent.INTERNAL, new tasks_events_1.TaskCreatedEvent({ id: taskWithRelations.createdByActorId }, taskWithRelations));
+        return this.mapTaskToResult(taskWithRelations);
+    }
+    async createTaskInThread(input) {
+        this.logger.log({
+            message: 'Creating task in thread',
+            name: input.name,
+            runId: input.runId,
+        });
+        const agentRun = await this.agentRunsService.getAgentRunById(input.runId);
+        if (agentRun.actorId !== input.createdByActorId) {
+            throw new Error(`Unauthorized: caller ${input.createdByActorId} is not the actor in agent run ${input.runId}`);
+        }
+        const parentTaskId = agentRun.parentTaskId;
+        const task = await this.createTask({
+            name: input.name,
+            description: input.description,
+            assigneeActorId: input.assigneeActorId,
+            sessionId: input.sessionId,
+            createdByActorId: input.createdByActorId,
+            tagNames: input.tagNames,
+            dependsOnIds: input.dependsOnIds,
+        });
+        let thread = await this.threadsService.findThreadByTaskId(parentTaskId);
+        if (thread) {
+            this.logger.log({
+                message: 'Attaching task to existing thread',
+                taskId: task.id,
+                threadId: thread.id,
+            });
+            await this.threadsService.attachTask(thread.id, task.id);
+        }
+        else {
+            this.logger.log({
+                message: 'Creating new thread for tasks',
+                parentTaskId,
+                newTaskId: task.id,
+            });
+            thread = await this.threadsService.createThread({
+                createdByActorId: input.createdByActorId,
+                taskIds: [parentTaskId, task.id],
+            });
+        }
+        this.logger.log({
+            message: 'Task created in thread',
+            taskId: task.id,
+            threadId: thread.id,
+            runId: input.runId,
+        });
+        return task;
+    }
+    async updateTask(taskId, input, actorId) {
+        this.logger.log({
+            message: 'Updating task',
+            taskId,
+        });
+        const task = await this.taskRepository.findOne({
+            where: { id: taskId },
+            relations: [
+                'comments',
+                'comments.commenterActor',
+                'inputRequests',
+                'tags',
+                'dependsOn',
+                'assigneeActor',
+                'createdByActor',
+            ],
+        });
+        if (!task) {
+            throw new tasks_errors_1.TaskNotFoundError(taskId);
+        }
+        if (input.name !== undefined)
+            task.name = input.name;
+        if (input.description !== undefined)
+            task.description = input.description;
+        if (input.sessionId !== undefined)
+            task.sessionId = input.sessionId ?? null;
+        if (input.assigneeActorId !== undefined) {
+            if (input.assigneeActorId === null) {
+                task.assigneeActorId = null;
+            }
+            else {
+                const assigneeActor = await this.actorService.getActorByIdOrSlug(input.assigneeActorId);
+                if (assigneeActor) {
+                    task.assigneeActorId = assigneeActor.id;
+                }
+                else {
+                }
+            }
+        }
+        if (input.tagNames !== undefined) {
+            if (input.tagNames.length === 0) {
+                task.tags = [];
+            }
+            else {
+                task.tags = await this.metaService.findOrCreateTagEntities(input.tagNames);
+            }
+        }
+        if (input.dependsOnIds !== undefined) {
+            if (input.dependsOnIds.length === 0) {
+                task.dependsOn = [];
+            }
+            else {
+                const dependencyTasks = await this.taskRepository.findBy({
+                    id: (0, typeorm_2.In)(input.dependsOnIds),
+                });
+                if (dependencyTasks.length !== input.dependsOnIds.length) {
+                    throw new Error('One or more dependency tasks not found');
+                }
+                task.dependsOn = dependencyTasks;
+            }
+        }
+        const updatedTask = await this.taskRepository.save(task);
+        const taskWithRelations = await this.taskRepository.findOne({
+            where: { id: taskId },
+            relations: [
+                'comments',
+                'comments.commenterActor',
+                'inputRequests',
+                'tags',
+                'dependsOn',
+                'assigneeActor',
+                'createdByActor',
+            ],
+        });
+        if (!taskWithRelations) {
+            throw new tasks_errors_1.TaskNotFoundError(taskId);
+        }
+        this.logger.log({
+            message: 'Task updated',
+            taskId: taskWithRelations.id,
+        });
+        this.eventEmitter.emit(tasks_events_1.TaskUpdatedEvent.INTERNAL, new tasks_events_1.TaskUpdatedEvent({ id: actorId }, taskWithRelations));
+        return this.mapTaskToResult(taskWithRelations);
+    }
+    async assignTask(taskId, input, actorId) {
+        this.logger.log({
+            message: 'Assigning task',
+            taskId,
+            assigneeActorId: input.assigneeActorId,
+            sessionId: input.sessionId,
+        });
+        this.logger.debug(`finding task ${taskId}`);
+        const task = await this.taskRepository.findOne({
+            where: { id: taskId },
+            relations: [
+                'comments',
+                'comments.commenterActor',
+                'inputRequests',
+                'tags',
+                'dependsOn',
+                'assigneeActor',
+                'createdByActor',
+            ],
+        });
+        if (!task) {
+            this.logger.debug(`task ${taskId} not found`);
+            throw new tasks_errors_1.TaskNotFoundError(taskId);
+        }
+        this.logger.debug(`task ${taskId} found`);
+        if (task.assigneeActorId === input.assigneeActorId) {
+            return this.mapTaskToResult(task);
+        }
+        task.assigneeActorId = input.assigneeActorId;
+        task.assigneeActor = undefined;
+        if (input.sessionId !== undefined) {
+            task.sessionId = input.sessionId || null;
+        }
+        this.logger.debug(`task ready to save:`, task);
+        const assignedTask = await this.taskRepository.save(task);
+        this.logger.debug(`saved task: ${assignedTask}`);
+        const taskWithRelations = await this.taskRepository.findOne({
+            where: { id: taskId },
+            relations: [
+                'comments',
+                'comments.commenterActor',
+                'inputRequests',
+                'tags',
+                'dependsOn',
+                'assigneeActor',
+                'createdByActor',
+            ],
+        });
+        this.logger.debug(`task from db`, taskWithRelations);
+        this.logger.log({
+            message: 'Task assigned',
+            taskId: assignedTask.id,
+            assignee: taskWithRelations?.assignee,
+            sessionId: assignedTask.sessionId,
+        });
+        this.eventEmitter.emit(tasks_events_1.TaskAssignedEvent.INTERNAL, new tasks_events_1.TaskAssignedEvent({ id: actorId }, taskWithRelations));
+        return this.mapTaskToResult(taskWithRelations);
+    }
+    async deleteTask(taskId, actorId) {
+        this.logger.log({
+            message: 'Deleting task',
+            taskId,
+        });
+        const task = await this.taskRepository.findOne({ where: { id: taskId } });
+        if (!task) {
+            throw new tasks_errors_1.TaskNotFoundError(taskId);
+        }
+        await this.taskRepository.softRemove(task);
+        this.logger.log({
+            message: 'Task deleted',
+            taskId,
+        });
+        this.eventEmitter.emit(tasks_events_1.TaskDeletedEvent.INTERNAL, new tasks_events_1.TaskDeletedEvent({ id: actorId }, taskId));
+    }
+    async listTasks(input) {
+        this.logger.log({
+            message: 'Listing tasks',
+            filters: {
+                assignee: input.assignee,
+                sessionId: input.sessionId,
+                tag: input.tag,
+            },
+            page: input.page,
+            limit: input.limit,
+        });
+        const skip = (input.page - 1) * input.limit;
+        if (input.tag) {
+            const queryBuilder = this.taskRepository
+                .createQueryBuilder('task')
+                .leftJoinAndSelect('task.comments', 'comments')
+                .leftJoinAndSelect('comments.commenterActor', 'commenterActor')
+                .leftJoinAndSelect('task.inputRequests', 'inputRequests')
+                .leftJoinAndSelect('task.tags', 'tags')
+                .leftJoinAndSelect('task.assigneeActor', 'assigneeActor')
+                .leftJoinAndSelect('task.createdByActor', 'createdByActor')
+                .innerJoin('task.tags', 'filterTag')
+                .where('filterTag.name = :tagName', { tagName: input.tag });
+            if (input.assignee) {
+                queryBuilder.andWhere('assigneeActor.slug = :assignee', {
+                    assignee: input.assignee,
+                });
+            }
+            if (input.sessionId) {
+                queryBuilder.andWhere('task.sessionId = :sessionId', {
+                    sessionId: input.sessionId,
+                });
+            }
+            queryBuilder
+                .orderBy('task.updatedAt', 'DESC')
+                .skip(skip)
+                .take(input.limit);
+            const [tasks, total] = await queryBuilder.getManyAndCount();
+            this.logger.log({
+                message: 'Tasks listed',
+                count: tasks.length,
+                total,
+                page: input.page,
+            });
+            return {
+                items: tasks.map((task) => this.mapTaskToResult(task)),
+                total,
+                page: input.page,
+                limit: input.limit,
+            };
+        }
+        const queryBuilder = this.taskRepository
+            .createQueryBuilder('task')
+            .leftJoinAndSelect('task.comments', 'comments')
+            .leftJoinAndSelect('comments.commenterActor', 'commenterActor')
+            .leftJoinAndSelect('task.inputRequests', 'inputRequests')
+            .leftJoinAndSelect('task.tags', 'tags')
+            .leftJoinAndSelect('task.dependsOn', 'dependsOn')
+            .leftJoinAndSelect('task.assigneeActor', 'assigneeActor')
+            .leftJoinAndSelect('task.createdByActor', 'createdByActor');
+        if (input.assignee) {
+            queryBuilder.andWhere('assigneeActor.slug = :assignee', {
+                assignee: input.assignee,
+            });
+        }
+        if (input.sessionId) {
+            queryBuilder.andWhere('task.sessionId = :sessionId', {
+                sessionId: input.sessionId,
+            });
+        }
+        queryBuilder.orderBy('task.updatedAt', 'DESC').skip(skip).take(input.limit);
+        const [tasks, total] = await queryBuilder.getManyAndCount();
+        this.logger.log({
+            message: 'Tasks listed',
+            count: tasks.length,
+            total,
+            page: input.page,
+        });
+        return {
+            items: tasks.map((task) => this.mapTaskToResult(task)),
+            total,
+            page: input.page,
+            limit: input.limit,
+        };
+    }
+    async getTaskById(taskId) {
+        const task = await this.taskRepository.findOne({
+            where: { id: taskId },
+            relations: [
+                'comments',
+                'comments.commenterActor',
+                'inputRequests',
+                'tags',
+                'dependsOn',
+                'assigneeActor',
+                'createdByActor',
+            ],
+        });
+        if (!task) {
+            throw new tasks_errors_1.TaskNotFoundError(taskId);
+        }
+        return this.mapTaskToResult(task);
+    }
+    async addComment(taskId, input) {
+        this.logger.log({
+            message: 'Adding comment',
+            taskId,
+        });
+        const task = await this.taskRepository.findOne({ where: { id: taskId } });
+        if (!task) {
+            throw new tasks_errors_1.TaskNotFoundError(taskId);
+        }
+        const comment = this.commentRepository.create({
+            task,
+            commenterActorId: input.commenterActorId,
+            content: input.content,
+        });
+        const savedComment = await this.commentRepository.save(comment);
+        const commentWithRelations = await this.commentRepository.findOne({
+            where: { id: savedComment.id },
+            relations: ['commenterActor', 'task'],
+        });
+        this.logger.log({
+            message: 'Comment added',
+            commentId: savedComment.id,
+            taskId,
+        });
+        this.eventEmitter.emit(tasks_events_1.CommentAddedEvent.INTERNAL, new tasks_events_1.CommentAddedEvent({ id: input.commenterActorId }, commentWithRelations));
+        return this.mapCommentToResult(commentWithRelations);
+    }
+    async changeStatus(taskId, input, actorId) {
+        this.logger.log({
+            message: 'Changing task status',
+            taskId,
+            status: input.status,
+        });
+        const task = await this.taskRepository.findOne({
+            where: { id: taskId },
+            relations: [
+                'comments',
+                'comments.commenterActor',
+                'inputRequests',
+                'tags',
+                'dependsOn',
+                'assigneeActor',
+                'createdByActor',
+            ],
+        });
+        if (!task) {
+            throw new tasks_errors_1.TaskNotFoundError(taskId);
+        }
+        if (input.status === enums_1.TaskStatus.IN_PROGRESS && !task.assigneeActorId) {
+            throw new tasks_errors_1.InvalidStatusTransitionError(task.status, input.status, 'Task must be assigned before moving to in progress');
+        }
+        if (input.status === enums_1.TaskStatus.DONE) {
+            const hasExistingComments = task.comments?.length > 0;
+            if (!input.comment && !hasExistingComments) {
+                throw new tasks_errors_1.CommentRequiredError();
+            }
+        }
+        if (input.status === enums_1.TaskStatus.DONE && input.comment) {
+            await this.commentRepository.save(this.commentRepository.create({
+                task,
+                commenterActorId: task.assigneeActorId,
+                content: input.comment,
+            }));
+        }
+        task.status = input.status;
+        const updatedTask = await this.taskRepository.save(task);
+        const taskWithRelations = await this.taskRepository.findOne({
+            where: { id: taskId },
+            relations: [
+                'comments',
+                'comments.commenterActor',
+                'inputRequests',
+                'tags',
+                'dependsOn',
+                'assigneeActor',
+                'createdByActor',
+            ],
+        });
+        if (!taskWithRelations) {
+            throw new tasks_errors_1.TaskNotFoundError(taskId);
+        }
+        this.logger.log({
+            message: 'Task status changed',
+            taskId,
+            status: taskWithRelations.status,
+        });
+        this.eventEmitter.emit(tasks_events_1.TaskStatusChangedEvent.INTERNAL, new tasks_events_1.TaskStatusChangedEvent({ id: actorId }, taskWithRelations));
+        return this.mapTaskToResult(taskWithRelations);
+    }
+    async addTagToTask(taskId, input, actorId) {
+        this.logger.log({
+            message: 'Adding tag to task',
+            taskId,
+            tagName: input.name,
+        });
+        const task = await this.taskRepository.findOne({
+            where: { id: taskId },
+            relations: [
+                'comments',
+                'comments.commenterActor',
+                'inputRequests',
+                'tags',
+                'dependsOn',
+                'assigneeActor',
+                'createdByActor',
+            ],
+        });
+        if (!task) {
+            throw new tasks_errors_1.TaskNotFoundError(taskId);
+        }
+        const tag = await this.metaService.findOrCreateTagEntity(input.name);
+        if (!task.tags.some((t) => t.id === tag.id)) {
+            task.tags.push(tag);
+            await this.taskRepository.save(task);
+            this.logger.log({
+                message: 'Tag added to task',
+                taskId,
+                tagId: tag.id,
+            });
+        }
+        const taskWithRelations = await this.taskRepository.findOne({
+            where: { id: taskId },
+            relations: [
+                'comments',
+                'comments.commenterActor',
+                'inputRequests',
+                'tags',
+                'dependsOn',
+                'assigneeActor',
+                'createdByActor',
+            ],
+        });
+        if (!taskWithRelations) {
+            throw new tasks_errors_1.TaskNotFoundError(taskId);
+        }
+        this.eventEmitter.emit(tasks_events_1.TaskUpdatedEvent.INTERNAL, new tasks_events_1.TaskUpdatedEvent({ id: actorId }, taskWithRelations));
+        return this.mapTaskToResult(taskWithRelations);
+    }
+    async removeTagFromTask(taskId, tagId, actorId) {
+        this.logger.log({
+            message: 'Removing tag from task',
+            taskId,
+            tagId,
+        });
+        const task = await this.taskRepository.findOne({
+            where: { id: taskId },
+            relations: [
+                'comments',
+                'comments.commenterActor',
+                'inputRequests',
+                'tags',
+                'dependsOn',
+                'assigneeActor',
+                'createdByActor',
+            ],
+        });
+        if (!task) {
+            throw new tasks_errors_1.TaskNotFoundError(taskId);
+        }
+        task.tags = task.tags.filter((tag) => tag.id !== tagId);
+        await this.taskRepository.save(task);
+        this.logger.log({
+            message: 'Tag removed from task',
+            taskId,
+            tagId,
+        });
+        await this.metaService.cleanupOrphanedTag(tagId);
+        const taskWithRelations = await this.taskRepository.findOne({
+            where: { id: taskId },
+            relations: [
+                'comments',
+                'comments.commenterActor',
+                'inputRequests',
+                'tags',
+                'dependsOn',
+                'assigneeActor',
+                'createdByActor',
+            ],
+        });
+        if (!taskWithRelations) {
+            throw new tasks_errors_1.TaskNotFoundError(taskId);
+        }
+        this.eventEmitter.emit(tasks_events_1.TaskUpdatedEvent.INTERNAL, new tasks_events_1.TaskUpdatedEvent({ id: actorId }, taskWithRelations));
+        return this.mapTaskToResult(taskWithRelations);
+    }
+    mapTaskToResult(task) {
+        if (!task.createdByActor) {
+            throw new Error(`Task ${task.id} is missing createdByActor relation`);
+        }
+        return {
+            id: task.id,
+            name: task.name,
+            description: task.description,
+            status: task.status,
+            assignee: task.assignee,
+            assigneeActor: task.assigneeActor
+                ? this.mapActorToResult(task.assigneeActor)
+                : null,
+            sessionId: task.sessionId,
+            comments: task.comments.map((c) => this.mapCommentToResult(c)),
+            inputRequests: (task.inputRequests || []).map((ir) => this.mapInputRequestToResult(ir)),
+            tags: (task.tags || []).map((t) => this.mapTagToResult(t)),
+            createdByActor: this.mapActorToResult(task.createdByActor),
+            dependsOnIds: (task.dependsOn || []).map((t) => t.id),
+            rowVersion: task.rowVersion,
+            createdAt: task.createdAt,
+            updatedAt: task.updatedAt,
+            deletedAt: task.deletedAt,
+        };
+    }
+    mapCommentToResult(comment) {
+        return {
+            id: comment.id,
+            taskId: comment.taskId,
+            commenterName: comment.commenterName,
+            commenterActor: comment.commenterActor
+                ? this.mapActorToResult(comment.commenterActor)
+                : null,
+            content: comment.content,
+            createdAt: comment.createdAt,
+        };
+    }
+    mapActorToResult(actor) {
+        return {
+            id: actor.id,
+            type: actor.type,
+            slug: actor.slug,
+            displayName: actor.displayName,
+            avatarUrl: actor.avatarUrl,
+            introduction: actor.introduction,
+        };
+    }
+    mapTagToResult(tag) {
+        return {
+            id: tag.id,
+            name: tag.name,
+            color: tag.color,
+            createdAt: tag.createdAt,
+            updatedAt: tag.updatedAt,
+        };
+    }
+    mapInputRequestToResult(inputRequest) {
+        return {
+            id: inputRequest.id,
+            taskId: inputRequest.taskId,
+            askedByActorId: inputRequest.askedByActorId,
+            assignedToActorId: inputRequest.assignedToActorId,
+            question: inputRequest.question,
+            answer: inputRequest.answer,
+            resolvedAt: inputRequest.resolvedAt,
+            createdAt: inputRequest.createdAt,
+            updatedAt: inputRequest.updatedAt,
+        };
+    }
+    async createInputRequest(input) {
+        this.logger.log({
+            message: 'Creating input request',
+            taskId: input.taskId,
+            assignedToActorId: input.assignedToActorId,
+        });
+        const task = await this.taskRepository.findOne({
+            where: { id: input.taskId },
+            relations: ['createdByActor'],
+        });
+        if (!task) {
+            throw new tasks_errors_1.TaskNotFoundError(input.taskId);
+        }
+        const assignedToActorId = input.assignedToActorId ?? task.createdByActorId;
+        const inputRequest = this.inputRequestRepository.create({
+            taskId: input.taskId,
+            askedByActorId: input.askedByActorId,
+            assignedToActorId: assignedToActorId,
+            question: input.question,
+            answer: null,
+            resolvedAt: null,
+        });
+        try {
+            const savedInputRequest = await this.inputRequestRepository.save(inputRequest);
+            this.logger.log({
+                message: 'Input request created',
+                inputRequestId: savedInputRequest.id,
+                taskId: input.taskId,
+                assignedToActorId: assignedToActorId,
+            });
+            const taskWithRelations = await this.taskRepository.findOne({
+                where: { id: input.taskId },
+                relations: [
+                    'comments',
+                    'comments.commenterActor',
+                    'inputRequests',
+                    'tags',
+                    'dependsOn',
+                    'assigneeActor',
+                    'createdByActor',
+                ],
+            });
+            if (!taskWithRelations) {
+                throw new tasks_errors_1.TaskNotFoundError(input.taskId);
+            }
+            this.eventEmitter.emit(tasks_events_1.TaskUpdatedEvent.INTERNAL, new tasks_events_1.TaskUpdatedEvent({ id: input.askedByActorId }, taskWithRelations));
+            return this.mapInputRequestToResult(savedInputRequest);
+        }
+        catch (error) {
+            this.logger.debug({
+                message: 'Input request creation failed, checking entities',
+                error: error.message,
+            });
+            const askedByActor = await this.actorRepository.findOne({
+                where: { id: input.askedByActorId },
+            });
+            if (!askedByActor) {
+                throw new tasks_errors_1.ActorNotFoundError(input.askedByActorId);
+            }
+            const assignedToActor = await this.actorRepository.findOne({
+                where: { id: assignedToActorId },
+            });
+            if (!assignedToActor) {
+                throw new tasks_errors_1.ActorNotFoundError(assignedToActorId);
+            }
+            throw error;
+        }
+    }
+    async answerInputRequest(taskId, inputRequestId, input, actorId) {
+        this.logger.log({
+            message: 'Answering input request',
+            taskId,
+            inputRequestId,
+        });
+        const inputRequest = await this.inputRequestRepository.findOne({
+            where: { id: inputRequestId, taskId },
+        });
+        if (!inputRequest) {
+            throw new Error(`Input request ${inputRequestId} not found for task ${taskId}`);
+        }
+        inputRequest.answer = input.answer;
+        inputRequest.resolvedAt = new Date();
+        const updatedInputRequest = await this.inputRequestRepository.save(inputRequest);
+        this.logger.log({
+            message: 'Input request answered',
+            inputRequestId,
+            taskId,
+        });
+        this.eventEmitter.emit(tasks_events_1.InputRequestAnsweredEvent.INTERNAL, new tasks_events_1.InputRequestAnsweredEvent({ id: actorId }, updatedInputRequest));
+        return this.mapInputRequestToResult(updatedInputRequest);
+    }
+    async searchTasks(input) {
+        this.logger.log({
+            message: 'Searching tasks',
+            query: input.query,
+            limit: input.limit,
+            threshold: input.threshold,
+        });
+        const tasks = await this.taskRepository.find({
+            relations: ['comments'],
+        });
+        const searchableItems = tasks.map((task) => ({
+            id: task.id,
+            name: task.name,
+            description: task.description,
+            commentsText: task.comments?.map((c) => c.content).join(' ') || '',
+        }));
+        const searchResults = this.searchService.search({
+            items: searchableItems,
+            primaryField: 'name',
+            secondaryField: 'description',
+            query: input.query,
+            limit: input.limit,
+            threshold: input.threshold,
+        });
+        this.logger.log({
+            message: 'Search completed',
+            resultCount: searchResults.length,
+        });
+        return searchResults.map((result) => ({
+            id: result.id,
+            name: result.primaryField,
+            score: result.score,
+        }));
+    }
+};
+exports.TasksService = TasksService;
+exports.TasksService = TasksService = TasksService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, typeorm_1.InjectRepository)(task_entity_1.TaskEntity)),
+    __param(1, (0, typeorm_1.InjectRepository)(comment_entity_1.CommentEntity)),
+    __param(2, (0, typeorm_1.InjectRepository)(input_request_entity_1.InputRequestEntity)),
+    __param(3, (0, typeorm_1.InjectRepository)(actor_entity_1.ActorEntity)),
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository,
+        typeorm_2.Repository,
+        actor_service_1.ActorService,
+        meta_service_1.MetaService,
+        event_emitter_1.EventEmitter2,
+        search_service_1.SearchService,
+        agent_runs_service_1.AgentRunsService,
+        threads_service_1.ThreadsService])
+], TasksService);
+//# sourceMappingURL=tasks.service.js.map