fix(tutor): propagate request cancellation

client/src/hooks/use-tutor.ts

@@ -111,6 +111,10 @@ function getCourseContentRequest(
   return {};
 }
 
+function isAbortError(error: unknown): boolean {
+  return error instanceof Error && error.name === "AbortError";
+}
+
 function buildDialogTurn(
   question: string,
   answer: string,
@@ -227,15 +231,23 @@ export function useTutor(
   const [isLoading, setIsLoading] = useState(false);
   const [error, setError] = useState<string | null>(null);
   const canLoadConfigOnMount = useRef(capabilities.canUseTutor);
+  const activeTutorRequests = useRef(new Set<AbortController>());
+  const abortPendingTutorRequests = useCallback(() => {
+    for (const controller of activeTutorRequests.current) controller.abort();
+    activeTutorRequests.current.clear();
+  }, []);
 
   useEffect(() => {
+    abortPendingTutorRequests();
     setCourseContentSession(undefined);
     setHistory([]);
     setQuestion(null);
     setAnswer("");
     setError(null);
     setEffectiveDifficulty(configuredDifficulty);
-  }, [courseContentKey]);
+  }, [abortPendingTutorRequests, courseContentKey]);
+
+  useEffect(() => () => abortPendingTutorRequests(), [abortPendingTutorRequests]);
 
   useEffect(() => {
     if (!canLoadConfigOnMount.current) return;
@@ -274,12 +286,15 @@ export function useTutor(
     }
 
     setModelsLoading(true);
+    const controller = new AbortController();
+    activeTutorRequests.current.add(controller);
     try {
       const response = await fetch("/api/tutor/models", {
         method: "POST",
         credentials: "include",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({ credential }),
+        signal: controller.signal,
       });
       const body: unknown = await response.json().catch(() => null);
       if (!response.ok) throw new Error(getErrorMessage(body));
@@ -288,10 +303,12 @@ export function useTutor(
       setAvailableModels(parsed.data.models);
       setSelectedModel((current) => current === "auto" || parsed.data.models.includes(current) ? current : "auto");
     } catch (requestError) {
+      if (controller.signal.aborted || isAbortError(requestError)) return;
       setAvailableModels([]);
       setSelectedModel("auto");
       setError(requestError instanceof Error ? requestError.message : "The Tutor models could not be loaded.");
     } finally {
+      activeTutorRequests.current.delete(controller);
       setModelsLoading(false);
     }
   }, [capabilities, credential]);
@@ -311,11 +328,14 @@ export function useTutor(
     if (selectedModel !== "auto" && !requestedModel) setSelectedModel("auto");
 
     setIsLoading(true);
+    const controller = new AbortController();
+    activeTutorRequests.current.add(controller);
     try {
       const response = await fetch("/api/tutor/question", {
         method: "POST",
         credentials: "include",
         headers: { "Content-Type": "application/json" },
+        signal: controller.signal,
         body: JSON.stringify({
           code,
           credential,
@@ -335,8 +355,10 @@ export function useTutor(
       setLastUsedModel(parsed.data.model);
       setAnswer("");
     } catch (requestError) {
+      if (controller.signal.aborted || isAbortError(requestError)) return;
       setError(requestError instanceof Error ? requestError.message : "The Tutor request failed.");
     } finally {
+      activeTutorRequests.current.delete(controller);
       setIsLoading(false);
     }
   }, [availableModels, capabilities, courseContent, courseContentSession, credential, selectedModel]);
@@ -381,11 +403,14 @@ export function useTutor(
     const currentHistory = history;
 
     setIsLoading(true);
+    const controller = new AbortController();
+    activeTutorRequests.current.add(controller);
     try {
       const response = await fetch("/api/tutor/dialog", {
         method: "POST",
         credentials: "include",
         headers: { "Content-Type": "application/json" },
+        signal: controller.signal,
         body: JSON.stringify({
           code,
           history: currentHistory,
@@ -413,8 +438,10 @@ export function useTutor(
     } catch (requestError) {
       // Keep the current question, answer, and history intact so a failed
       // request can be retried deliberately by the learner.
+      if (controller.signal.aborted || isAbortError(requestError)) return;
       setError(requestError instanceof Error ? requestError.message : "The Tutor request failed.");
     } finally {
+      activeTutorRequests.current.delete(controller);
       setIsLoading(false);
     }
   }, [answer, availableModels, capabilities, courseContent, courseContentSession, credential, effectiveDifficulty, history, question, selectedModel]);

server/routes/tutor.routes.ts

@@ -103,13 +103,33 @@ function requireRequestCredential(req: Request, res: Response, credential: strin
   return true;
 }
 
+function bindRequestAbortSignal(req: Request, res: Response): AbortSignal {
+  const controller = new AbortController();
+  const abort = () => controller.abort(new DOMException("Request aborted", "AbortError"));
+  const cleanup = () => {
+    req.off("aborted", abort);
+    res.off("close", onClose);
+    res.off("finish", cleanup);
+  };
+  const onClose = () => {
+    if (!res.writableEnded) abort();
+    cleanup();
+  };
+  req.once("aborted", abort);
+  res.once("close", onClose);
+  res.once("finish", cleanup);
+  if ((req.destroyed && !req.complete) || res.destroyed) abort();
+  return controller.signal;
+}
+
 export function registerTutorRoutes(app: Express, deps: TutorRouteDeps = {}): void {
   const logger = deps.logger ?? new Logger("TutorRoutes");
   const service = deps.service ?? createTutorService(new KiconnectProvider());
   const rateLimiter = deps.rateLimiter ?? (deps.disableRateLimit ? undefined : getTutorRateLimiter());
   const sessionStore = deps.sessionStore ?? new TutorCourseContentSessionStore();
 
   app.post("/api/tutor/question", async (req, res) => {
+    const signal = bindRequestAbortSignal(req, res);
     if (!enforceTutorRateLimit(res, { ...deps, rateLimiter })) return;
 
     const parsed = tutorQuestionRequestSchema.safeParse(req.body);
@@ -120,22 +140,26 @@ export function registerTutorRoutes(app: Express, deps: TutorRouteDeps = {}): vo
     if (!requireRequestCredential(req, res, parsed.data.credential)) return;
 
     try {
-      const content = await resolveTutorContent(req, res, parsed.data.courseContent, parsed.data.courseContentSession, deps.courseContent, sessionStore);
+      const content = await resolveTutorContent(req, res, parsed.data.courseContent, parsed.data.courseContentSession, deps.courseContent, sessionStore, signal);
+      if (signal.aborted) return;
       if ((parsed.data.courseContent !== undefined || parsed.data.courseContentSession !== undefined) && !content) return;
       const generated = await service.generateQuestion(
         parsed.data.code,
         parsed.data.credential,
         parsed.data.model,
         parsed.data.difficulty,
         content?.planning,
+        signal,
       );
+      if (signal.aborted) return;
       res.json({
         ...generated.result,
         provider: config.tutor.provider,
         model: generated.model,
         ...(content?.session ? { courseContentSession: content.session } : {}),
       });
     } catch (error) {
+      if (signal.aborted) return;
       if (error instanceof TutorProviderError) {
         mapProviderError(res, error);
         return;
@@ -146,6 +170,7 @@ export function registerTutorRoutes(app: Express, deps: TutorRouteDeps = {}): vo
   });
 
   app.post("/api/tutor/models", async (req, res) => {
+    const signal = bindRequestAbortSignal(req, res);
     if (!enforceTutorRateLimit(res, { ...deps, rateLimiter })) return;
 
     const parsed = tutorModelsRequestSchema.safeParse(req.body);
@@ -156,9 +181,11 @@ export function registerTutorRoutes(app: Express, deps: TutorRouteDeps = {}): vo
     if (!requireRequestCredential(req, res, parsed.data.credential)) return;
 
     try {
-      const models = await service.getAvailableModels(parsed.data.credential);
+      const models = await service.getAvailableModels(parsed.data.credential, signal);
+      if (signal.aborted) return;
       res.json({ models });
     } catch (error) {
+      if (signal.aborted) return;
       if (error instanceof TutorProviderError) {
         mapProviderError(res, error);
         return;
@@ -169,6 +196,7 @@ export function registerTutorRoutes(app: Express, deps: TutorRouteDeps = {}): vo
   });
 
   app.post("/api/tutor/dialog", async (req, res) => {
+    const signal = bindRequestAbortSignal(req, res);
     if (!enforceTutorRateLimit(res, { ...deps, rateLimiter })) return;
 
     const parsed = tutorDialogRequestSchema.safeParse(req.body);
@@ -179,7 +207,8 @@ export function registerTutorRoutes(app: Express, deps: TutorRouteDeps = {}): vo
     if (!requireRequestCredential(req, res, parsed.data.credential)) return;
 
     try {
-      const content = await resolveTutorContent(req, res, parsed.data.courseContent, parsed.data.courseContentSession, deps.courseContent, sessionStore);
+      const content = await resolveTutorContent(req, res, parsed.data.courseContent, parsed.data.courseContentSession, deps.courseContent, sessionStore, signal);
+      if (signal.aborted) return;
       if ((parsed.data.courseContent !== undefined || parsed.data.courseContentSession !== undefined) && !content) return;
       const generated = await service.generateDialogResponse(
         parsed.data.code,
@@ -190,14 +219,17 @@ export function registerTutorRoutes(app: Express, deps: TutorRouteDeps = {}): vo
         parsed.data.model,
         parsed.data.difficulty,
         content?.planning,
+        signal,
       );
+      if (signal.aborted) return;
       res.json({
         ...generated.result,
         provider: config.tutor.provider,
         model: generated.model,
         ...(content?.session ? { courseContentSession: content.session } : {}),
       });
     } catch (error) {
+      if (signal.aborted) return;
       if (error instanceof TutorProviderError) {
         mapProviderError(res, error);
         return;
@@ -215,7 +247,9 @@ async function resolveTutorContent(
   sessionHandle: string | undefined,
   resolver: TutorCourseContentResolver | undefined,
   sessions: TutorCourseContentSessionStore,
+  signal: AbortSignal,
 ): Promise<{ readonly planning: TutorPlanningContentContext; readonly session: string } | undefined> {
+  if (signal.aborted) return undefined;
   const identity = (res.locals.unosimIdentity as RequestIdentity | undefined)?.subject ?? "anonymous";
   if (sessionHandle !== undefined) {
     const pinned = sessions.get(identity, sessionHandle);
@@ -233,14 +267,17 @@ async function resolveTutorContent(
   const context: RequestContext = {
     identity,
     requestId: req.header("x-request-id") ?? randomUUID(),
+    signal,
   };
   let resolved: ResolvedTutorCourseContent;
   try {
     resolved = await resolver.resolveTutorContent(request, context);
   } catch {
+    if (signal.aborted) return undefined;
     responseError(res, 400, "INVALID_REQUEST", "Der Course-Content-Kontext ist ungültig oder nicht mehr aktiv.");
     return undefined;
   }
+  if (signal.aborted) return undefined;
   const handle = sessions.create(identity, resolved);
   return { planning: resolved, session: handle };
 }

server/services/course-content/course-content-loader.ts

@@ -141,7 +141,10 @@ export class CourseContentLoader {
       const strategies = await this.loadStrategies(base, manifest, signal);
       validateTutorReferences(manifest, topicEntries, strategies, annotations);
       return { status: "valid", manifest, topics: topicEntries, strategies };
-    } catch {
+    } catch (error) {
+      if (signal?.aborted) {
+        throw signal?.reason ?? error;
+      }
       return { status: "invalid", reason: "Tutor capability is invalid" };
     }
   }