utn-mcp 0.2.0 → 0.6.7

package/build/aula-virtual/format/activities.js

@@ -0,0 +1,101 @@
+import { htmlToText } from "../../shared/html.js";
+import { getAssignments, getChoiceOptions, getChoicegroupOptions, getChoices, getSubmissionStatus, } from "../client/client.js";
+import { isoDate, toFile } from "./fields.js";
+const SUBMISSION_STATUS_LABELS = {
+    new: "sin entregar",
+    draft: "borrador",
+    submitted: "enviada",
+    reopened: "reabierta",
+};
+/** La entrega del usuario (o la de su grupo): qué acepta la tarea, qué subió y la devolución si la hay. */
+export async function viewSubmission(session, courseId, module) {
+    const [assignments, status] = await Promise.all([
+        getAssignments(session, courseId),
+        getSubmissionStatus(session, module.instance),
+    ]);
+    const assignment = assignments.find((a) => a.cmid === module.id);
+    const attempt = status.lastattempt;
+    // En las entregas grupales la individual queda vacía; la que cuenta es la del grupo.
+    const submission = attempt?.teamsubmission ?? attempt?.submission;
+    const config = (plugin, name) => assignment?.configs.find((c) => c.subtype === "assignsubmission" && c.plugin === plugin && c.name === name)
+        ?.value;
+    const accepts = [];
+    if (config("file", "enabled") === "1") {
+        accepts.push({
+            tipo: "archivos",
+            maximo: Number(config("file", "maxfilesubmissions")) || undefined,
+            tamanioMaximo: Number(config("file", "maxsubmissionsizebytes")) || undefined,
+            extensiones: config("file", "filetypeslist") || undefined,
+        });
+    }
+    if (config("onlinetext", "enabled") === "1") {
+        accepts.push({ tipo: "texto en línea", limitePalabras: Number(config("onlinetext", "wordlimit")) || undefined });
+    }
+    const feedback = status.feedback;
+    return {
+        estado: submission ? (SUBMISSION_STATUS_LABELS[submission.status] ?? submission.status) : "sin entregar",
+        grupal: assignment?.teamsubmission === 1 || undefined,
+        // Moodle crea la entrega vacía al abrir la tarea: su fecha no dice nada hasta que hay algo subido.
+        modificada: (submission?.status !== "new" && isoDate(submission?.timemodified)) || undefined,
+        abre: isoDate(assignment?.allowsubmissionsfromdate) || undefined,
+        vence: isoDate(assignment?.duedate) || undefined,
+        prorroga: isoDate(attempt?.extensionduedate) || undefined,
+        cierreDefinitivo: isoDate(assignment?.cutoffdate) || undefined,
+        acepta: accepts.length ? accepts : undefined,
+        // Con borradores, lo subido no cuenta hasta confirmar el envío.
+        requiereConfirmarEnvio: assignment?.submissiondrafts === 1 || undefined,
+        requiereDeclaracion: assignment?.requiresubmissionstatement === 1 || undefined,
+        puedeEditar: attempt?.canedit ?? false,
+        puedeEnviar: attempt?.cansubmit || undefined,
+        bloqueada: attempt?.locked || undefined,
+        ...pluginContent(submission?.plugins),
+        devolucion: feedback
+            ? {
+                calificacion: feedback.gradefordisplay || undefined,
+                fecha: isoDate(feedback.gradeddate),
+                ...pluginContent(feedback.plugins),
+            }
+            : undefined,
+    };
+}
+/** Los archivos y textos de una entrega o devolución, sin los plugins vacíos. */
+function pluginContent(plugins = []) {
+    const files = plugins.flatMap((p) => p.fileareas?.flatMap((a) => a.files ?? []) ?? []);
+    const texts = plugins
+        .flatMap((p) => p.editorfields ?? [])
+        .map((e) => htmlToText(e.text))
+        .filter(Boolean);
+    return {
+        archivos: files.length ? files.map(toFile) : undefined,
+        texto: texts.length ? texts.join("\n\n") : undefined,
+    };
+}
+export async function viewChoice(session, courseId, module) {
+    const [choices, options] = await Promise.all([
+        getChoices(session, courseId),
+        getChoiceOptions(session, module.instance),
+    ]);
+    const choice = choices.find((c) => c.coursemodule === module.id);
+    return {
+        multiple: choice?.allowmultiple || undefined,
+        puedeCambiar: choice?.allowupdate,
+        abre: isoDate(choice?.timeopen) || undefined,
+        cierra: isoDate(choice?.timeclose) || undefined,
+        opciones: options.map(toOption),
+    };
+}
+/** El plugin no expone si deja cambiar o elegir varios grupos: eso lo dice la descripción o el error al elegir. */
+export async function viewChoicegroup(session, module) {
+    const options = await getChoicegroupOptions(session, module.instance);
+    return { opciones: options.map(toOption) };
+}
+export function toOption(o) {
+    return {
+        id: o.id,
+        texto: o.text ?? o.name,
+        elegida: o.checked || undefined,
+        deshabilitada: o.disabled || undefined,
+        cupo: o.maxanswers || undefined,
+        anotados: o.countanswers,
+    };
+}

package/build/aula-virtual/format/address.js

@@ -0,0 +1,52 @@
+export const ROOT = "/";
+export const courseAddr = (courseId) => `/curso/${courseId}`;
+export const moduleAddr = (courseId, cmid) => `/curso/${courseId}/mod/${cmid}`;
+export const discussionAddr = (courseId, cmid, discussionId) => `/curso/${courseId}/mod/${cmid}/disc/${discussionId}`;
+const FORMATS = [
+    "/",
+    "/curso/{courseId}",
+    "/curso/{courseId}/mod/{cmid}",
+    "/curso/{courseId}/mod/{cmid}/disc/{discussionId}",
+].join(", ");
+const PATTERN = /^\/curso\/(\d+)(?:\/mod\/(\d+)(?:\/disc\/(\d+))?)?$/;
+export function parseAddress(raw) {
+    const path = raw.trim().replace(/\/+$/, "") || "/";
+    if (path === "/")
+        return { level: "root" };
+    const m = PATTERN.exec(path);
+    if (!m)
+        throw new Error(`Dirección inválida: "${raw}". Formatos válidos: ${FORMATS}`);
+    const [, course, cmid, disc] = m;
+    const courseId = Number(course);
+    if (!cmid)
+        return { level: "course", courseId };
+    if (!disc)
+        return { level: "module", courseId, cmid: Number(cmid) };
+    return { level: "discussion", courseId, cmid: Number(cmid), discussionId: Number(disc) };
+}
+/** La dirección en texto, tal como la ve el modelo. */
+export function formatAddress(address) {
+    switch (address.level) {
+        case "root":
+            return ROOT;
+        case "course":
+            return courseAddr(address.courseId);
+        case "module":
+            return moduleAddr(address.courseId, address.cmid);
+        case "discussion":
+            return discussionAddr(address.courseId, address.cmid, address.discussionId);
+    }
+}
+/** La dirección de un nivel más arriba, o null si ya estamos en la raíz. */
+export function parentOf(address) {
+    switch (address.level) {
+        case "root":
+            return null;
+        case "course":
+            return ROOT;
+        case "module":
+            return courseAddr(address.courseId);
+        case "discussion":
+            return moduleAddr(address.courseId, address.cmid);
+    }
+}

package/build/aula-virtual/format/fields.js

@@ -0,0 +1,14 @@
+import { userFacingUrl } from "./files.js";
+/** Los timestamps de Moodle (segundos) en ISO; 0 o vacío es "sin fecha". */
+export const isoDate = (seconds) => seconds ? new Date(seconds * 1000).toISOString() : null;
+export function toFile(f) {
+    return {
+        nombre: f.filename,
+        ruta: f.filepath || undefined,
+        tamanio: f.filesize,
+        mimetype: f.mimetype,
+        modificado: isoDate(f.timemodified),
+        // Sirve para pasársela al usuario y también para leerlo con aula_read_file.
+        url: userFacingUrl(f.fileurl),
+    };
+}

package/build/aula-virtual/format/files.js

@@ -0,0 +1,89 @@
+import { openDocument, UnsupportedFormat } from "../../shared/documents/index.js";
+import { AULA_BASE_URL } from "../client/constants.js";
+import { fetchFile } from "../client/moodle-api.js";
+const ORIGIN = new URL(AULA_BASE_URL).origin;
+const WS_PATH = "/webservice/pluginfile.php/";
+const WEB_PATH = "/pluginfile.php/";
+/** Cuánto se devuelve por llamada, en caracteres de texto. */
+const BUDGET_CHARS = 30_000;
+/** Lo que cuesta una página como imagen (~1.600 tokens), medido en caracteres de texto. */
+const IMAGE_COST_CHARS = 6_000;
+/** El más grande que hay hoy en los cursos pesa 12 MB. */
+const MAX_BYTES = 30 * 1024 * 1024;
+/**
+ * Moodle devuelve las URLs del web service, que piden token. Al usuario le sirve la misma ruta sin
+ * `/webservice`, que se abre con la sesión de su navegador. Es la única que mostramos: el token no
+ * sale nunca del servidor.
+ */
+export function userFacingUrl(fileurl) {
+    return fileurl.replace(`${ORIGIN}${WS_PATH}`, `${ORIGIN}${WEB_PATH}`);
+}
+/**
+ * Acepta cualquiera de las dos formas y devuelve la del web service. Solo archivos del aula: con
+ * cualquier otra URL estaríamos mandando el token del usuario a donde diga el modelo.
+ */
+function downloadUrl(url) {
+    let u;
+    try {
+        u = new URL(url);
+    }
+    catch {
+        throw new Error(`URL inválida: "${url}". Usá la \`url\` de un archivo tal como la devuelve aula_open.`);
+    }
+    const path = u.pathname.startsWith(WS_PATH) ? u.pathname : u.pathname.startsWith(WEB_PATH) ? WS_PATH + u.pathname.slice(WEB_PATH.length) : null;
+    if (u.origin !== ORIGIN || !path) {
+        throw new Error(`Solo se pueden leer archivos del aula virtual (${ORIGIN}${WEB_PATH}...).`);
+    }
+    u.pathname = path;
+    u.searchParams.delete("token");
+    u.searchParams.delete("wstoken");
+    return u;
+}
+/** Baja un archivo del aula y devuelve desde la parte `from` tantas como entren en el presupuesto. */
+export async function readAulaFile(session, url, from = 1) {
+    const download = downloadUrl(url);
+    const fileName = decodeURIComponent(download.pathname.split("/").pop() ?? "");
+    const forUser = userFacingUrl(download.href);
+    const { bytes } = await fetchFile(session, download, MAX_BYTES);
+    let doc;
+    try {
+        doc = await openDocument(bytes, fileName);
+    }
+    catch (e) {
+        if (e instanceof UnsupportedFormat) {
+            throw new Error(`${e.message} El usuario lo puede bajar desde ${forUser}`);
+        }
+        throw e;
+    }
+    try {
+        if (from > doc.total) {
+            throw new Error(`"${fileName}" termina en ${doc.unit} ${doc.total}; se pidió desde ${from}.`);
+        }
+        const parts = [];
+        let spent = 0;
+        let n = from;
+        for (; n <= doc.total; n++) {
+            const part = await doc.part(n);
+            const cost = "text" in part ? part.text.length : IMAGE_COST_CHARS;
+            // Siempre al menos una parte, aunque sola se pase del presupuesto.
+            if (parts.length > 0 && spent + cost > BUDGET_CHARS)
+                break;
+            parts.push({ ...part, number: n });
+            spent += cost;
+        }
+        return {
+            archivo: fileName,
+            formato: doc.format,
+            unidad: doc.unit,
+            total: doc.total,
+            desde: from,
+            hasta: n - 1,
+            siguiente: n <= doc.total ? n : undefined,
+            urlParaUsuario: forUser,
+            parts,
+        };
+    }
+    finally {
+        await doc.close();
+    }
+}

package/build/aula-virtual/format/navigate.js

@@ -0,0 +1,143 @@
+import { htmlToSnippet, htmlToText } from "../../shared/html.js";
+import { courseAddr, discussionAddr, formatAddress, moduleAddr, parentOf, parseAddress, } from "./address.js";
+import { canAddDiscussion, getCourseSections, getDiscussionPosts, getForumDiscussions, getUserCourses, PAGE_SIZE, } from "../client/client.js";
+import { viewChoice, viewChoicegroup, viewSubmission } from "./activities.js";
+import { isoDate, toFile } from "./fields.js";
+/**
+ * Entra a una dirección del aula y devuelve su contenido, el padre y las direcciones de lo que hay
+ * adentro. Es el único lugar que decide qué ve el modelo y cuánto texto le cuesta.
+ */
+export async function open(session, rawAddress, page = 0) {
+    const address = parseAddress(rawAddress);
+    const base = { direccion: formatAddress(address), padre: parentOf(address) };
+    switch (address.level) {
+        case "root":
+            return { ...base, cursos: await viewCourses(session) };
+        case "course":
+            return { ...base, secciones: await viewCourse(session, address.courseId) };
+        case "module":
+            return { ...base, ...(await viewModule(session, address, page)) };
+        case "discussion":
+            return { ...base, ...(await viewDiscussion(session, address.discussionId)) };
+    }
+}
+async function viewCourses(session) {
+    const courses = await getUserCourses(session);
+    return courses.map((c) => ({
+        direccion: courseAddr(c.id),
+        id: c.id,
+        nombre: c.fullname,
+        nombreCorto: c.shortname,
+        visible: c.visible === 1,
+        progreso: c.progress ?? null,
+        ultimoAcceso: isoDate(c.lastaccess),
+    }));
+}
+/** El mapa del curso: secciones y módulos, con las descripciones recortadas. */
+async function viewCourse(session, courseId) {
+    const sections = await getCourseSections(session, courseId);
+    return sections
+        .filter((s) => s.uservisible !== false)
+        .map((s) => ({
+        nombre: s.name,
+        numero: s.section,
+        resumen: htmlToText(s.summary) || undefined,
+        modulos: s.modules.filter((m) => m.uservisible).map((m) => toModule(m, courseId, true)),
+    }))
+        .filter((s) => s.resumen || s.modulos.length > 0);
+}
+async function viewModule(session, address, page) {
+    const { sectionName, module } = await findModule(session, address.courseId, address.cmid);
+    const base = { seccion: sectionName, modulo: toModule(module, address.courseId) };
+    switch (module.modname) {
+        case "forum":
+            return { ...base, ...(await viewForum(session, address, module.instance, page)) };
+        case "assign":
+            return { ...base, entrega: await viewSubmission(session, address.courseId, module) };
+        case "choice":
+            return { ...base, eleccion: await viewChoice(session, address.courseId, module) };
+        case "choicegroup":
+            return { ...base, eleccion: await viewChoicegroup(session, module) };
+        default:
+            return base;
+    }
+}
+/** Un foro es un índice: asuntos y un fragmento de cada uno. El mensaje completo sale al abrir la discusión. */
+async function viewForum(session, address, forumid, page) {
+    const [{ discussions }, canStartDiscussion] = await Promise.all([
+        getForumDiscussions(session, forumid, page),
+        canAddDiscussion(session, forumid),
+    ]);
+    return {
+        puedeAbrirHilo: canStartDiscussion,
+        discusiones: discussions.map((d) => ({
+            direccion: discussionAddr(address.courseId, address.cmid, d.discussion),
+            asunto: d.subject,
+            autor: d.userfullname,
+            autorId: d.userid,
+            fecha: isoDate(d.created),
+            ultimaActividad: isoDate(d.timemodified),
+            respuestas: d.numreplies,
+            fijada: d.pinned || undefined,
+            adjuntos: d.attachment || undefined,
+            resumen: htmlToSnippet(d.message),
+        })),
+        pagina: page,
+        hayMasDiscusiones: discussions.length === PAGE_SIZE || undefined,
+    };
+}
+async function viewDiscussion(session, discussionId) {
+    const { posts } = await getDiscussionPosts(session, discussionId);
+    const visible = posts.filter((p) => !p.isdeleted);
+    return {
+        asunto: visible[0]?.subject,
+        publicaciones: visible.map((p) => ({
+            autor: p.author.fullname,
+            autorId: p.author.id,
+            fecha: isoDate(p.timecreated),
+            respuestaA: p.parentid ?? undefined,
+            id: p.id,
+            mensaje: htmlToText(p.message),
+            adjuntos: p.attachments.length ? p.attachments.map(toFile) : undefined,
+            // Lo que el usuario puede hacer con cada publicación, para no intentar lo que Moodle va a rechazar.
+            acciones: allowedActions(p.capabilities),
+        })),
+    };
+}
+function allowedActions(c) {
+    const allowed = [c.reply && "responder", c.edit && "editar", c.delete && "borrar"].filter(Boolean);
+    return allowed.length ? allowed : undefined;
+}
+/** Ubica un módulo por su cmid y se queda con la sección que lo contiene. */
+export async function findModule(session, courseId, cmid) {
+    const sections = await getCourseSections(session, courseId, cmid);
+    for (const section of sections) {
+        const module = section.modules.find((m) => m.id === cmid);
+        if (!module)
+            continue;
+        if (!module.uservisible)
+            throw new Error(`No tenés acceso al módulo ${cmid}.`);
+        return { sectionName: section.name, module };
+    }
+    throw new Error(`No existe el módulo ${cmid} en el curso ${courseId}.`);
+}
+/** `summarized` recorta la descripción: en el mapa del curso alcanza para decidir si entrar. */
+function toModule(m, courseId, summarized = false) {
+    const contents = m.contents ?? [];
+    const files = contents.filter((c) => c.type === "file");
+    const links = contents.filter((c) => c.type === "url");
+    return {
+        direccion: moduleAddr(courseId, m.id),
+        id: m.id,
+        nombre: m.name,
+        tipo: m.modname,
+        url: m.url,
+        descripcion: (summarized ? htmlToSnippet(m.description) : htmlToText(m.description)) || undefined,
+        restriccion: htmlToText(m.availabilityinfo) || undefined,
+        fechas: m.dates?.length
+            ? m.dates.map((d) => ({ etiqueta: d.label, fecha: isoDate(d.timestamp) }))
+            : undefined,
+        archivos: files.length ? files.map(toFile) : undefined,
+        enlaces: links.length ? links.map((l) => l.fileurl) : undefined,
+    };
+}

package/build/aula-virtual/tools.js

@@ -1,8 +1,9 @@
 import * as z from "zod";
 import { getSiteInfo } from "./client/client.js";
-import { RAIZ } from "./address.js";
-import { leerArchivo } from "./files.js";
-import { open } from "./navigate.js";
+import { addCalendarEvent, answerChoice, deleteForumPost, editForumPost, postToForum, sendMessage, } from "./format/actions.js";
+import { ROOT } from "./format/address.js";
+import { readAulaFile } from "./format/files.js";
+import { open } from "./format/navigate.js";
 // JSON compacto: indentar estas respuestas cuesta ~25% más de contexto y no se lee mejor.
 const json = (data) => ({
     content: [{ type: "text", text: JSON.stringify(data) }],
@@ -11,8 +12,13 @@ const failure = (e) => ({
     content: [{ type: "text", text: `Error: ${e.message}` }],
     isError: true,
 });
+/** Para que el cliente distinga las tools que leen de las que cambian algo en el aula. */
+const READ_ONLY = { readOnlyHint: true, openWorldHint: false };
 export function registerAulaVirtualTools(server, session) {
-    server.registerTool("aula_get_site_info", { description: "Datos del usuario logueado en el aula virtual de la UTN FRBA y del sitio Moodle." }, async () => {
+    server.registerTool("aula_get_site_info", {
+        description: "Datos del usuario logueado en el aula virtual de la UTN FRBA y del sitio Moodle.",
+        annotations: READ_ONLY,
+    }, async () => {
         try {
             const { sitename, fullname, username, userid, release } = await getSiteInfo(session);
             return json({ sitename, fullname, username, userid, release });
@@ -24,9 +30,10 @@ export function registerAulaVirtualTools(server, session) {
     server.registerTool("aula_list_courses", {
         description: "Lista los cursos (materias) en los que está inscripto el usuario. Es el punto de entrada: " +
             "cada curso viene con su `direccion`, que se le pasa a aula_open para entrar.",
+        annotations: READ_ONLY,
     }, async () => {
         try {
-            return json(await open(session, RAIZ));
+            return json(await open(session, ROOT));
         }
         catch (e) {
             return failure(e);
@@ -36,6 +43,11 @@ export function registerAulaVirtualTools(server, session) {
         description: "Entra a una dirección del aula virtual y devuelve lo que hay ahí: un curso con sus secciones " +
             "y módulos, un módulo con sus archivos y fechas, un foro con el índice de sus discusiones, o " +
             "una discusión con sus mensajes completos.\n\n" +
+            "Según el tipo de módulo trae además: en una tarea (assign), `entrega` con el estado, el " +
+            "vencimiento, lo que se subió y la devolución con la nota; en una elección (choice) o " +
+            "selección de grupos (choicegroup), `eleccion` con las opciones y sus ids; en un foro, " +
+            "`puedeAbrirHilo`; en una discusión, el `id`, el `autorId` y las `acciones` permitidas de " +
+            "cada publicación. Es lo que piden las tools que escriben en el aula.\n\n" +
             "No hace falta armar la dirección: cada respuesta trae las direcciones de lo que hay adentro " +
             "(`direccion`) y la de un nivel más arriba (`padre`), así que se navega pasando de vuelta una " +
             "de esas. Para empezar, usar aula_list_courses o la dirección \"/\".\n\n" +
@@ -57,6 +69,7 @@ export function registerAulaVirtualTools(server, session) {
                 .describe("Solo para foros: página del índice de discusiones, de 50 en 50. La respuesta avisa " +
                 "con `hayMasDiscusiones` cuando hay otra."),
         }),
+        annotations: READ_ONLY,
     }, async ({ direccion, pagina }) => {
         try {
             return json(await open(session, direccion, pagina));
@@ -82,20 +95,21 @@ export function registerAulaVirtualTools(server, session) {
                 .optional()
                 .describe("Número de página, diapositiva o fragmento desde el cual leer. Por defecto, 1."),
         }),
+        annotations: READ_ONLY,
     }, async ({ url, desde }) => {
         try {
-            const { partes, ...lectura } = await leerArchivo(session, url, desde);
-            const etiqueta = (n, titulo) => `--- ${lectura.unidad} ${n} de ${lectura.total}${titulo ? ` (${titulo})` : ""} ---`;
+            const { parts, ...fileRead } = await readAulaFile(session, url, desde);
+            const label = (n, title) => `--- ${fileRead.unidad} ${n} de ${fileRead.total}${title ? ` (${title})` : ""} ---`;
             return {
                 content: [
-                    { type: "text", text: JSON.stringify(lectura) },
-                    ...partes.flatMap((p) => "texto" in p
-                        ? [{ type: "text", text: `${etiqueta(p.numero, p.titulo)}\n${p.texto}` }]
+                    { type: "text", text: JSON.stringify(fileRead) },
+                    ...parts.flatMap((p) => "text" in p
+                        ? [{ type: "text", text: `${label(p.number, p.title)}\n${p.text}` }]
                         : [
-                            { type: "text", text: etiqueta(p.numero, p.titulo) },
+                            { type: "text", text: label(p.number, p.title) },
                             {
                                 type: "image",
-                                data: Buffer.from(p.imagen).toString("base64"),
+                                data: Buffer.from(p.image).toString("base64"),
                                 mimeType: p.mimeType,
                             },
                         ]),
@@ -106,4 +120,168 @@ export function registerAulaVirtualTools(server, session) {
             return failure(e);
         }
     });
+    // --- Escritura: lo que sigue cambia algo en el aula, y casi todo queda a la vista de otras personas. ---
+    const CONFIRM_FIRST = "\n\nAntes de llamarla, mostrale al usuario exactamente lo que se va a hacer y esperá que confirme.";
+    server.registerTool("aula_forum_post", {
+        description: "Publica en un foro del aula virtual. Con la `direccion` de un foro abre un hilo nuevo (hace " +
+            "falta `asunto`); con la de una discusión responde en ella, a la publicación `respuestaA` o, " +
+            "si no se indica, a la primera.\n\n" +
+            "Lo que se publica lo ven docentes y compañeros, y a muchos les llega por mail. Antes de abrir " +
+            "un hilo, mirá `puedeAbrirHilo` del foro; antes de responder, que la publicación tenga " +
+            '"responder" en `acciones`.' +
+            CONFIRM_FIRST,
+        inputSchema: z.object({
+            direccion: z
+                .string()
+                .describe('Dirección de un foro o de una discusión. Ej: "/curso/691/mod/34831" o ' +
+                '"/curso/691/mod/34831/disc/416676".'),
+            mensaje: z
+                .string()
+                .min(1)
+                .describe("Texto del mensaje, en texto plano. Una línea en blanco separa párrafos. " +
+                'Ej: "Hola, ¿el parcial incluye la unidad 4?"'),
+            asunto: z
+                .string()
+                .optional()
+                .describe('Obligatorio para abrir un hilo. En una respuesta, por defecto "Re: <asunto>". ' +
+                'Ej: "Consulta sobre el parcial".'),
+            respuestaA: z
+                .number()
+                .int()
+                .optional()
+                .describe("Solo al responder: `id` de la publicación a la que se responde, de aula_open. Ej: 768118."),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async ({ direccion, mensaje, asunto, respuestaA }) => {
+        try {
+            return json(await postToForum(session, direccion, mensaje, asunto, respuestaA));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+    server.registerTool("aula_forum_edit_post", {
+        description: "Edita una publicación propia de un foro y reemplaza el mensaje completo. Solo se puede si la " +
+            'publicación tiene "editar" en `acciones`: Moodle deja editar por un rato después de publicar.' +
+            CONFIRM_FIRST,
+        inputSchema: z.object({
+            direccion: z
+                .string()
+                .describe('Dirección de la discusión donde está la publicación. Ej: "/curso/691/mod/34831/disc/416676".'),
+            id: z.number().int().describe("`id` de la publicación, de aula_open. Ej: 768118."),
+            mensaje: z
+                .string()
+                .min(1)
+                .describe('El mensaje nuevo completo, en texto plano; reemplaza al anterior. Ej: "Ya lo resolví, gracias."'),
+            asunto: z
+                .string()
+                .optional()
+                .describe('Asunto nuevo. Si no se pasa, queda el que tenía. Ej: "Consulta sobre el parcial (resuelta)".'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    }, async ({ direccion, id, mensaje, asunto }) => {
+        try {
+            return json(await editForumPost(session, direccion, id, mensaje, asunto));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+    server.registerTool("aula_forum_delete_post", {
+        description: "Borra una publicación propia de un foro. No se puede deshacer. Solo se puede si tiene " +
+            '"borrar" en `acciones`. Si es la primera publicación de la discusión, se borra la discusión ' +
+            "entera." +
+            CONFIRM_FIRST,
+        inputSchema: z.object({
+            direccion: z
+                .string()
+                .describe('Dirección de la discusión donde está la publicación. Ej: "/curso/691/mod/34831/disc/416676".'),
+            id: z.number().int().describe("`id` de la publicación, de aula_open. Ej: 768118."),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
+    }, async ({ direccion, id }) => {
+        try {
+            return json(await deleteForumPost(session, direccion, id));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+    server.registerTool("aula_choice_answer", {
+        description: 'Responde una elección (choice: encuestas rápidas como "¿venís al parcial?") o una selección ' +
+            "de grupos (choicegroup: anotarse en un grupo o comisión). Deja elegidas exactamente las " +
+            "`opciones` pasadas y reemplaza la respuesta anterior; con una lista vacía la borra.\n\n" +
+            "Las opciones salen de `eleccion` al abrir el módulo con aula_open. Muchas no dejan cambiar " +
+            "la respuesta una vez dada (`puedeCambiar: false`), y las opciones `deshabilitada` están " +
+            "completas. Devuelve cómo quedó la elección." +
+            CONFIRM_FIRST,
+        inputSchema: z.object({
+            direccion: z.string().describe('Dirección del módulo. Ej: "/curso/29487/mod/1729113".'),
+            opciones: z
+                .array(z.number().int())
+                .describe("`id` de las opciones a elegir. Ej: [31076]. Varias solo si la actividad lo permite."),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    }, async ({ direccion, opciones }) => {
+        try {
+            return json(await answerChoice(session, direccion, opciones));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+    server.registerTool("aula_send_message", {
+        description: "Manda un mensaje privado por la mensajería del aula virtual a otro usuario, docente o " +
+            "compañero. El `usuarioId` sale del `autorId` de un foro o una discusión abiertos con " +
+            "aula_open: no lo inventes ni lo deduzcas del nombre. La respuesta trae el nombre del " +
+            "destinatario." +
+            CONFIRM_FIRST +
+            " Incluí a quién va dirigido.",
+        inputSchema: z.object({
+            usuarioId: z.number().int().describe("Id del destinatario, del `autorId` de aula_open. Ej: 1066."),
+            mensaje: z
+                .string()
+                .min(1)
+                .describe('Texto del mensaje, en texto plano. Ej: "Profe, ¿puedo rendir el recuperatorio el viernes?"'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, async ({ usuarioId, mensaje }) => {
+        try {
+            return json(await sendMessage(session, usuarioId, mensaje));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
+    server.registerTool("aula_calendar_add_event", {
+        description: "Agrega un evento personal al calendario del aula virtual, que solo ve el usuario: por ejemplo " +
+            "un recordatorio de un parcial o una entrega. El aula avisa según la configuración de " +
+            "notificaciones del usuario. La fecha va con zona horaria; en Argentina es -03:00.",
+        inputSchema: z.object({
+            nombre: z.string().min(1).describe('Título del evento. Ej: "Parcial de Física II".'),
+            inicio: z
+                .string()
+                .describe('Fecha y hora en ISO 8601 con zona horaria. Ej: "2026-10-14T18:00:00-03:00".'),
+            duracionMinutos: z
+                .number()
+                .int()
+                .min(0)
+                .optional()
+                .describe("Duración en minutos. Por defecto, sin duración. Ej: 120."),
+            descripcion: z.string().optional().describe('Detalle, en texto plano. Ej: "Aula 312, unidades 1 a 4".'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false },
+    }, async ({ nombre, inicio, duracionMinutos, descripcion }) => {
+        try {
+            return json(await addCalendarEvent(session, {
+                name: nombre,
+                start: inicio,
+                durationMinutes: duracionMinutos,
+                description: descripcion,
+            }));
+        }
+        catch (e) {
+            return failure(e);
+        }
+    });
 }

package/build/server.js

@@ -4,7 +4,7 @@ import { registerAulaVirtualTools } from "./aula-virtual/tools.js";
 export function createServer(aula) {
     const server = new McpServer({
         name: "UTN-MCP",
-        version: "0.2.0",
+        version: "0.6.7",
     });
     registerAulaVirtualTools(server, aula);
     return server;