Iris: Add Artemis Intelligence rewrite action for FAQs

src/main/java/de/tum/cit/aet/artemis/communication/web/conversation/RephrasingResource.java

@@ -0,0 +1,61 @@
+package de.tum.cit.aet.artemis.communication.web.conversation;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_IRIS;
+
+import java.util.Optional;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Profile;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.PathVariable;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+import de.tum.cit.aet.artemis.core.repository.CourseRepository;
+import de.tum.cit.aet.artemis.core.repository.UserRepository;
+import de.tum.cit.aet.artemis.iris.service.IrisRephrasingService;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.rephrasing.RephrasingVariant;
+
+/**
+ * REST controller for managing Markdown Rephrasings.
+ */
+@Profile(PROFILE_IRIS)
+@RestController
+@RequestMapping("api/")
+public class RephrasingResource {
+
+    @Value("${jhipster.clientApp.name}")
+    private String applicationName;
+
+    private static final Logger log = LoggerFactory.getLogger(RephrasingResource.class);
+
+    private static final String ENTITY_NAME = "rephrasing";
+
+    private final UserRepository userRepository;
+
+    private final CourseRepository courseRepository;
+
+    private final Optional<IrisRephrasingService> irisRephrasingService;
+
+    public RephrasingResource(UserRepository userRepository, CourseRepository courseRepository, Optional<IrisRephrasingService> irisRephrasingService) {
+        this.userRepository = userRepository;
+        this.courseRepository = courseRepository;
+        this.irisRephrasingService = irisRephrasingService;
+
+    }
+
+    @PostMapping("courses/{courseId}/rephrase-text")
+    public ResponseEntity<Void> rephraseText(@RequestParam String toBeRephrased, @RequestParam RephrasingVariant variant, @PathVariable Long courseId) {
+        var rephrasingService = irisRephrasingService.orElseThrow();
+        var user = userRepository.getUserWithGroupsAndAuthorities();
+        var course = courseRepository.findByIdElseThrow(courseId);
+        rephrasingService.executeRephrasingPipeline(user, course, variant, toBeRephrased);
+        log.debug("REST request to rephrase text: {}", toBeRephrased);
+        return ResponseEntity.ok().build();
+    }
+
+}

src/main/java/de/tum/cit/aet/artemis/iris/service/IrisRephrasingService.java

@@ -0,0 +1,96 @@
+package de.tum.cit.aet.artemis.iris.service;
+
+import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_IRIS;
+
+import java.util.Optional;
+
+import org.springframework.context.annotation.Profile;
+import org.springframework.stereotype.Service;
+
+import de.tum.cit.aet.artemis.core.domain.Course;
+import de.tum.cit.aet.artemis.core.domain.LLMServiceType;
+import de.tum.cit.aet.artemis.core.domain.User;
+import de.tum.cit.aet.artemis.core.repository.CourseRepository;
+import de.tum.cit.aet.artemis.core.repository.UserRepository;
+import de.tum.cit.aet.artemis.core.service.LLMTokenUsageService;
+import de.tum.cit.aet.artemis.iris.service.pyris.PyrisJobService;
+import de.tum.cit.aet.artemis.iris.service.pyris.PyrisPipelineService;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.rephrasing.PyrisRephrasingPipelineExecutionDTO;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.rephrasing.PyrisRephrasingStatusUpdateDTO;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.rephrasing.RephrasingVariant;
+import de.tum.cit.aet.artemis.iris.service.pyris.job.RephrasingJob;
+import de.tum.cit.aet.artemis.iris.service.websocket.IrisWebsocketService;
+
+/**
+ * Service to handle the Competency generation subsystem of Iris.
+ */
+@Service
+@Profile(PROFILE_IRIS)
+public class IrisRephrasingService {
+
+    private final PyrisPipelineService pyrisPipelineService;
+
+    private final LLMTokenUsageService llmTokenUsageService;
+
+    private final CourseRepository courseRepository;
+
+    private final IrisWebsocketService websocketService;
+
+    private final PyrisJobService pyrisJobService;
+
+    private final UserRepository userRepository;
+
+    public IrisRephrasingService(PyrisPipelineService pyrisPipelineService, LLMTokenUsageService llmTokenUsageService, CourseRepository courseRepository,
+            IrisWebsocketService websocketService, PyrisJobService pyrisJobService, UserRepository userRepository) {
+        this.pyrisPipelineService = pyrisPipelineService;
+        this.llmTokenUsageService = llmTokenUsageService;
+        this.courseRepository = courseRepository;
+        this.websocketService = websocketService;
+        this.pyrisJobService = pyrisJobService;
+        this.userRepository = userRepository;
+    }
+
+    /**
+     * Executes the competency extraction pipeline on Pyris for a given course, user and course description
+     *
+     * @param user          the user for which the pipeline should be executed
+     * @param course        the course for which the pipeline should be executed
+     * @param toBeRephrased the description of the course
+     */
+    public void executeRephrasingPipeline(User user, Course course, RephrasingVariant variant, String toBeRephrased) {
+        // @formatter:off
+        pyrisPipelineService.executePipeline(
+                "rephrasing",
+                variant.toString(),
+                Optional.empty(),
+                pyrisJobService.createTokenForJob(token -> new RephrasingJob(token, course.getId(), user.getId())),
+                executionDto -> new PyrisRephrasingPipelineExecutionDTO(executionDto, toBeRephrased),
+                stages -> websocketService.send(user.getLogin(), websocketTopic(course.getId()), new PyrisRephrasingStatusUpdateDTO(stages, null, null))
+        );
+        // @formatter:on
+    }
+
+    /**
+     * Takes a status update from Pyris containing a new competency extraction result and sends it to the client via websocket
+     *
+     * @param job          Job related to the status update
+     * @param statusUpdate the status update containing the new competency recommendations
+     * @return the same job that was passed in
+     */
+    public RephrasingJob handleStatusUpdate(RephrasingJob job, PyrisRephrasingStatusUpdateDTO statusUpdate) {
+        Course course = courseRepository.findByIdForUpdateElseThrow(job.courseId());
+        if (statusUpdate.tokens() != null && !statusUpdate.tokens().isEmpty()) {
+            llmTokenUsageService.saveLLMTokenUsage(statusUpdate.tokens(), LLMServiceType.IRIS, builder -> builder.withCourse(course.getId()).withUser(job.userId()));
+        }
+
+        var user = userRepository.findById(job.userId()).orElseThrow();
+        websocketService.send(user.getLogin(), websocketTopic(job.courseId()), statusUpdate);
+
+        return job;
+    }
+
+    private static String websocketTopic(long courseId) {
+        return "rephrasing/" + courseId;
+    }
+
+}

src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisStatusUpdateService.java

@@ -10,17 +10,20 @@
 import org.springframework.stereotype.Service;
 
 import de.tum.cit.aet.artemis.iris.service.IrisCompetencyGenerationService;
+import de.tum.cit.aet.artemis.iris.service.IrisRephrasingService;
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.chat.PyrisChatStatusUpdateDTO;
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.chat.textexercise.PyrisTextExerciseChatStatusUpdateDTO;
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.competency.PyrisCompetencyStatusUpdateDTO;
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.lectureingestionwebhook.PyrisLectureIngestionStatusUpdateDTO;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.rephrasing.PyrisRephrasingStatusUpdateDTO;
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.status.PyrisStageDTO;
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.status.PyrisStageState;
 import de.tum.cit.aet.artemis.iris.service.pyris.job.CompetencyExtractionJob;
 import de.tum.cit.aet.artemis.iris.service.pyris.job.CourseChatJob;
 import de.tum.cit.aet.artemis.iris.service.pyris.job.ExerciseChatJob;
 import de.tum.cit.aet.artemis.iris.service.pyris.job.IngestionWebhookJob;
 import de.tum.cit.aet.artemis.iris.service.pyris.job.PyrisJob;
+import de.tum.cit.aet.artemis.iris.service.pyris.job.RephrasingJob;
 import de.tum.cit.aet.artemis.iris.service.pyris.job.TextExerciseChatJob;
 import de.tum.cit.aet.artemis.iris.service.pyris.job.TrackedSessionBasedPyrisJob;
 import de.tum.cit.aet.artemis.iris.service.session.IrisCourseChatSessionService;
@@ -41,16 +44,19 @@ public class PyrisStatusUpdateService {
 
     private final IrisCompetencyGenerationService competencyGenerationService;
 
+    private final IrisRephrasingService rephrasingService;
+
     private static final Logger log = LoggerFactory.getLogger(PyrisStatusUpdateService.class);
 
     public PyrisStatusUpdateService(PyrisJobService pyrisJobService, IrisExerciseChatSessionService irisExerciseChatSessionService,
             IrisTextExerciseChatSessionService irisTextExerciseChatSessionService, IrisCourseChatSessionService courseChatSessionService,
-            IrisCompetencyGenerationService competencyGenerationService) {
+            IrisCompetencyGenerationService competencyGenerationService, IrisRephrasingService rephrasingService) {
         this.pyrisJobService = pyrisJobService;
         this.irisExerciseChatSessionService = irisExerciseChatSessionService;
         this.irisTextExerciseChatSessionService = irisTextExerciseChatSessionService;
         this.courseChatSessionService = courseChatSessionService;
         this.competencyGenerationService = competencyGenerationService;
+        this.rephrasingService = rephrasingService;
     }
 
     /**
@@ -105,6 +111,18 @@ public void handleStatusUpdate(CompetencyExtractionJob job, PyrisCompetencyStatu
         removeJobIfTerminatedElseUpdate(statusUpdate.stages(), updatedJob);
     }
 
+    /**
+     * Handles the status update of a competency extraction job and forwards it to
+     * {@link IrisCompetencyGenerationService#handleStatusUpdate(CompetencyExtractionJob, PyrisCompetencyStatusUpdateDTO)}
+     *
+     * @param job          the job that is updated
+     * @param statusUpdate the status update
+     */
+    public void handleStatusUpdate(RephrasingJob job, PyrisRephrasingStatusUpdateDTO statusUpdate) {
+        var updatedJob = rephrasingService.handleStatusUpdate(job, statusUpdate);
+        removeJobIfTerminatedElseUpdate(statusUpdate.stages(), updatedJob);
+    }
+
     /**
      * Removes the job from the job service if the status update indicates that the job is terminated; updates it to distribute changes otherwise.
      * A job is terminated if all stages are in a terminal state.

src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/rephrasing/PyrisRephrasingDTO.java

@@ -0,0 +1,16 @@
+package de.tum.cit.aet.artemis.iris.service.pyris.dto.rephrasing;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+/**
+ * DTO for the Iris rephrasing feature.
+ * A rephrasing is just a text and determines the variant of the rephrasing.
+ *
+ * @param text    The rephrased text
+ * @param variant The variant of the rephrasing
+ *
+ *
+ */
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public record PyrisRephrasingDTO(String text, RephrasingVariant variant) {
+}

src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/rephrasing/PyrisRephrasingPipelineExecutionDTO.java

@@ -0,0 +1,15 @@
+package de.tum.cit.aet.artemis.iris.service.pyris.dto.rephrasing;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.PyrisPipelineExecutionDTO;
+
+/**
+ * DTO to execute the Iris competency extraction pipeline on Pyris
+ *
+ * @param execution     The pipeline execution details
+ * @param toBeRephrased The text to be rephrased
+ */
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public record PyrisRephrasingPipelineExecutionDTO(PyrisPipelineExecutionDTO execution, String toBeRephrased) {
+}

src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/rephrasing/PyrisRephrasingStatusUpdateDTO.java

@@ -0,0 +1,21 @@
+package de.tum.cit.aet.artemis.iris.service.pyris.dto.rephrasing;
+
+import java.util.List;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import de.tum.cit.aet.artemis.core.domain.LLMRequest;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.status.PyrisStageDTO;
+
+/**
+ * DTO for the Iris rephrasing feature.
+ * Pyris sends callback updates back to Artemis during rephrasing of the text. These updates contain the current status of the rephrasing process,
+ * which are then forwarded to the user via Websockets.
+ *
+ * @param stages List of stages of the generation process
+ * @param result The result of the rephrasing process so far
+ * @param tokens List of token usages send by Pyris for tracking the token usage and cost
+ */
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public record PyrisRephrasingStatusUpdateDTO(List<PyrisStageDTO> stages, String result, List<LLMRequest> tokens) {
+}

src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/rephrasing/RephrasingVariant.java

@@ -0,0 +1,5 @@
+package de.tum.cit.aet.artemis.iris.service.pyris.dto.rephrasing;
+
+public enum RephrasingVariant {
+    FAQ, PROBLEM_STATEMENT
+}

src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/job/RephrasingJob.java

@@ -0,0 +1,22 @@
+package de.tum.cit.aet.artemis.iris.service.pyris.job;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import de.tum.cit.aet.artemis.core.domain.Course;
+
+/**
+ * A pyris job that rephrases a text.
+ *
+ * @param jobId    the job id
+ * @param courseId the course in which the rephrasing is being done
+ * @param userId   the user who started the job
+ */
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public record RephrasingJob(String jobId, long courseId, long userId) implements PyrisJob {
+
+    @Override
+    public boolean canAccess(Course course) {
+        return course.getId().equals(courseId);
+    }
+
+}

src/main/java/de/tum/cit/aet/artemis/iris/web/open/PublicPyrisStatusUpdateResource.java

@@ -23,11 +23,13 @@
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.chat.textexercise.PyrisTextExerciseChatStatusUpdateDTO;
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.competency.PyrisCompetencyStatusUpdateDTO;
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.lectureingestionwebhook.PyrisLectureIngestionStatusUpdateDTO;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.rephrasing.PyrisRephrasingStatusUpdateDTO;
 import de.tum.cit.aet.artemis.iris.service.pyris.job.CompetencyExtractionJob;
 import de.tum.cit.aet.artemis.iris.service.pyris.job.CourseChatJob;
 import de.tum.cit.aet.artemis.iris.service.pyris.job.ExerciseChatJob;
 import de.tum.cit.aet.artemis.iris.service.pyris.job.IngestionWebhookJob;
 import de.tum.cit.aet.artemis.iris.service.pyris.job.PyrisJob;
+import de.tum.cit.aet.artemis.iris.service.pyris.job.RephrasingJob;
 import de.tum.cit.aet.artemis.iris.service.pyris.job.TextExerciseChatJob;
 
 /**
@@ -149,6 +151,31 @@ public ResponseEntity<Void> respondInTextExerciseChat(@PathVariable String runId
         return ResponseEntity.ok().build();
     }
 
+    /**
+     * POST public/pyris/pipelines/rephrasing/runs/:runId/status : Send the rephrased text in a status update
+     * <p>
+     * Uses custom token based authentication.
+     *
+     * @param runId           the ID of the job
+     * @param statusUpdateDTO the status update
+     * @param request         the HTTP request
+     * @throws ConflictException        if the run ID in the URL does not match the run ID in the request body
+     * @throws AccessForbiddenException if the token is invalid
+     * @return a {@link ResponseEntity} with status {@code 200 (OK)}
+     */
+    @PostMapping("pipelines/rephrasing/runs/{runId}/status")
+    @EnforceNothing
+    public ResponseEntity<Void> setRephrasingJobStatus(@PathVariable String runId, @RequestBody PyrisRephrasingStatusUpdateDTO statusUpdateDTO, HttpServletRequest request) {
+        var job = pyrisJobService.getAndAuthenticateJobFromHeaderElseThrow(request, RephrasingJob.class);
+        if (!Objects.equals(job.jobId(), runId)) {
+            throw new ConflictException("Run ID in URL does not match run ID in request body", "Job", "runIdMismatch");
+        }
+
+        pyrisStatusUpdateService.handleStatusUpdate(job, statusUpdateDTO);
+
+        return ResponseEntity.ok().build();
+    }
+
     /**
      * {@code POST /api/public/pyris/webhooks/ingestion/runs/{runId}/status} : Set the status of an Ingestion job.
      *

src/main/webapp/app/faq/faq-update.component.html

@@ -21,6 +21,7 @@ <h2 id="jhi-faq-heading" jhiTranslate="artemisApp.faq.home.createOrEditLabel"></
                         id="field_description"
                         class="markdown-editor"
                         [domainActions]="domainActionsDescription"
+                        [metaActions]="metaActions"
                         [markdown]="faq.questionAnswer"
                         (markdownChange)="handleMarkdownChange($event)"
                     />