Offer courses and rooms as MCP resources, with two German prompts

A course or room can now be attached to a message rather than fetched:
schulcloud://courses/<id> and schulcloud://rooms/<id> carry exactly what
get_course and get_room return. Deliberately coarse — a picker lists every
resource at once, which suits some twenty courses and not a thousand files.

Two prompts, in German because the school is: zusammenfassung summarises a
course or room, and pruefungsvorbereitung prepares for an exam with practice
questions and a study plan. Each embeds the overview and says where material
hides and what cannot be read.

Claude Code shaped the details, read from its bundle rather than its docs.
It splits prompt arguments on whitespace and drops extra words, so words
arrive joined with "_", and courses match by fragments, whole words first,
so LF1 is not ambiguous with LF10. Its @ autocomplete shows a resource's
description, so the description carries the name. Errors are ProtocolError,
because McpError's message prefix is doubled by the client.

Verified in interactive Claude Code: @-mention, autocomplete and the prompt
commands. 157 tests. Smoke 67/67 live; 69/69 and 67/67 on the local instance.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

scripts/smoke.mjs

@@ -303,6 +303,100 @@ console.log('\n== rooms ==');
 	}
 }
 
+console.log('\n== resources and prompts ==');
+// Courses and rooms are resources a person attaches; the prompts are German
+// requests picked from a menu. Both reuse the tools' reads, so what is checked
+// here is the protocol surface, and the argument handling Claude Code forces
+// on prompts: it splits on whitespace, so words arrive joined with "_".
+{
+	const { resources } = await client.listResources();
+	const courseResources = resources.filter((r) => r.uri.startsWith('schulcloud://courses/'));
+	const roomResources = resources.filter((r) => r.uri.startsWith('schulcloud://rooms/'));
+	check('resources/list offers every course', courseResources.length === courseIds.length, `${courseResources.length} of ${courseIds.length}`);
+	const roomsListed = await call('list_rooms');
+	const roomCount = [...roomsListed.text.matchAll(/\(`([0-9a-f]{24})`\)/g)].length;
+	check('resources/list offers every room', roomResources.length === roomCount, `${roomResources.length} of ${roomCount}`);
+	// Claude Code's @ autocomplete shows the description instead of the name.
+	check(
+		'every resource description carries its name',
+		resources.length > 0 && resources.every((r) => r.name && r.mimeType === 'text/markdown' && r.description?.endsWith(r.name)),
+	);
+	const { resourceTemplates } = await client.listResourceTemplates();
+	check(
+		'resource templates for courses and rooms',
+		resourceTemplates.map((t) => t.uriTemplate).sort().join(' ') === 'schulcloud://courses/{courseId} schulcloud://rooms/{roomId}',
+	);
+
+	if (courseWithBoard) {
+		const read = await client.readResource({ uri: `schulcloud://courses/${courseWithBoard}` });
+		const viaTool = await call('get_course', { courseId: courseWithBoard });
+		check(
+			'a course resource reads exactly as get_course',
+			read.contents[0]?.mimeType === 'text/markdown' && read.contents[0]?.text === viaTool.text,
+			read.contents[0]?.text?.split('\n')[0],
+		);
+	}
+	if (roomResources[0]) {
+		const room = await client.readResource({ uri: roomResources[0].uri });
+		check('a room resource opens', /Room id:/.test(room.contents[0]?.text ?? ''), roomResources[0].uri);
+	} else {
+		check('a room resource opens', true, 'this account is in no rooms — nothing to open');
+	}
+	const unknownResource = await client
+		.readResource({ uri: 'schulcloud://courses/000000000000000000000000' })
+		.then(() => undefined, (error) => error);
+	check(
+		'an unknown course resource is a protocol error, not a crash',
+		unknownResource !== undefined,
+		unknownResource?.message?.split('\n')[0],
+	);
+
+	const { prompts } = await client.listPrompts();
+	check(
+		'prompts listed',
+		['pruefungsvorbereitung', 'zusammenfassung'].every((name) => prompts.some((p) => p.name === name)),
+		prompts.map((p) => p.name).join(', '),
+	);
+	const courseTitle = courseWithBoard
+		? courses.text.match(new RegExp(`- \\*\\*(.+?)\\*\\* \\(\`${courseWithBoard}\`\\)`))?.[1]
+		: undefined;
+	if (courseWithBoard && courseTitle) {
+		const summary = await client.getPrompt({
+			name: 'zusammenfassung',
+			arguments: { kurs: courseTitle.split(/\s+/).join('_') },
+		});
+		const [embedded, instructions] = summary.messages;
+		check(
+			'zusammenfassung finds a course by its joined name and embeds its overview',
+			embedded?.content.type === 'resource' && embedded.content.resource.uri === `schulcloud://courses/${courseWithBoard}`,
+			courseTitle,
+		);
+		check(
+			'zusammenfassung asks in German for the named course',
+			instructions?.content.type === 'text' &&
+				instructions.content.text.includes(`„${courseTitle}“`) &&
+				/Antworte auf Deutsch/.test(instructions.content.text),
+		);
+		const exam = await client.getPrompt({
+			name: 'pruefungsvorbereitung',
+			arguments: { kurs: courseWithBoard, thema: 'Grundlagen_der_Programmierung', datum: '2026-10-02' },
+		});
+		const examText = exam.messages[1]?.content.type === 'text' ? exam.messages[1].content.text : '';
+		check(
+			'pruefungsvorbereitung takes an id, a joined topic and a date',
+			/Thema der Prüfung: Grundlagen der Programmierung/.test(examText) && /Prüfungstermin: 2026-10-02/.test(examText),
+		);
+	}
+	const refused = await client
+		.getPrompt({ name: 'zusammenfassung', arguments: { kurs: 'kein_solcher_kurs_xyz' } })
+		.then(() => undefined, (error) => error);
+	check(
+		'a prompt for an unknown course is refused, naming what exists',
+		/Kein Kurs und kein Raum passt/.test(refused?.message ?? ''),
+		refused?.message?.slice(0, 100),
+	);
+}
+
 console.log('\n== search ==');
 const searchTerm = process.env.SMOKE_SEARCH ?? 'Datenschutz';
 const search = await call('search', { query: searchTerm, fresh: true, courseId: courseIds[0] });