@charlie.act7/canvas-mcp-server 1.1.8 → 1.2.0

package/dist/services/canvas-client.js

@@ -1,15 +1,17 @@
 import axios from 'axios';
 export class CanvasClient {
     client;
+    quizClient;
     token;
     domain;
     constructor(token, domain) {
         this.token = token;
         this.domain = domain;
         this.client = this.createAxiosInstance(token, domain);
+        this.quizClient = this.createAxiosInstance(token, domain, 'api/quiz/v1');
     }
-    createAxiosInstance(token, domain) {
-        const baseURL = `https://${domain}/api/v1`;
+    createAxiosInstance(token, domain, apiPath = 'api/v1') {
+        const baseURL = `https://${domain}/${apiPath}`;
         return axios.create({
             baseURL,
             headers: {
@@ -22,6 +24,7 @@ export class CanvasClient {
         this.token = token;
         this.domain = domain;
         this.client = this.createAxiosInstance(token, domain);
+        this.quizClient = this.createAxiosInstance(token, domain, 'api/quiz/v1');
     }
     parseLinkHeader(header) {
         if (!header)
@@ -189,9 +192,6 @@ export class CanvasClient {
         await this.client.delete(url);
         return { deleted: true, comment_id: commentId };
     }
-    async getSubmissionComments(courseId, assignmentId, userId) {
-        return this.getSingleSubmission(courseId, assignmentId, userId);
-    }
     async getDiscussionTopics(courseId) {
         return this.getAllPages(`courses/${courseId}/discussion_topics`);
     }
@@ -213,6 +213,11 @@ export class CanvasClient {
         });
         return response.data;
     }
+    async updateAnnouncement(courseId, topicId, fields) {
+        const url = `courses/${courseId}/discussion_topics/${topicId}`;
+        const response = await this.client.put(url, fields);
+        return response.data;
+    }
     // --- Quiz Questions ---
     async listQuizQuestions(courseId, quizId) {
         return this.getAllPages(`courses/${courseId}/quizzes/${quizId}/questions`, {
@@ -378,6 +383,15 @@ export class CanvasClient {
         return { deleted: true };
     }
     // --- Rubrics ---
+    async getRubrics(courseId) {
+        return this.getAllPages(`courses/${courseId}/rubrics`);
+    }
+    async getRubric(courseId, rubricId, include) {
+        const response = await this.client.get(`courses/${courseId}/rubrics/${rubricId}`, {
+            params: { include }
+        });
+        return response.data;
+    }
     async createRubric(courseId, rubricData, rubricAssociationData) {
         const payload = { rubric: rubricData };
         if (rubricAssociationData) {
@@ -386,6 +400,14 @@ export class CanvasClient {
         const response = await this.client.post(`courses/${courseId}/rubrics`, payload);
         return response.data;
     }
+    async updateRubric(courseId, rubricId, rubricData, rubricAssociationData) {
+        const payload = { rubric: rubricData };
+        if (rubricAssociationData) {
+            payload.rubric_association = rubricAssociationData;
+        }
+        const response = await this.client.put(`courses/${courseId}/rubrics/${rubricId}`, payload);
+        return response.data;
+    }
     async createRubricAssociation(courseId, associationData) {
         const response = await this.client.post(`courses/${courseId}/rubric_associations`, {
             rubric_association: associationData
@@ -456,4 +478,225 @@ export class CanvasClient {
         const response = await this.client.post(`groups/${groupId}/memberships`, { user_id: userId });
         return response.data;
     }
+    // --- Course Management ---
+    async createCourse(accountId, data) {
+        const response = await this.client.post(`accounts/${accountId}/courses`, { course: data });
+        return response.data;
+    }
+    async updateCourse(courseId, data) {
+        const response = await this.client.put(`courses/${courseId}`, { course: data });
+        return response.data;
+    }
+    async getSyllabus(courseId) {
+        const response = await this.client.get(`courses/${courseId}`, { params: { include: ['syllabus_body'] } });
+        return response.data;
+    }
+    async healthCheck() {
+        const response = await this.client.get('users/self/profile');
+        return { status: 'ok', user: response.data.name, domain: this.domain };
+    }
+    // --- Assignment ---
+    async deleteAssignment(courseId, assignmentId) {
+        await this.client.delete(`courses/${courseId}/assignments/${assignmentId}`);
+        return { deleted: true };
+    }
+    // --- Pages ---
+    async deletePage(courseId, pageUrlOrId) {
+        await this.client.delete(`courses/${courseId}/pages/${pageUrlOrId}`);
+        return { deleted: true };
+    }
+    // --- Discussions ---
+    async createDiscussion(courseId, data) {
+        const response = await this.client.post(`courses/${courseId}/discussion_topics`, data);
+        return response.data;
+    }
+    async deleteDiscussion(courseId, topicId) {
+        await this.client.delete(`courses/${courseId}/discussion_topics/${topicId}`);
+        return { deleted: true };
+    }
+    // --- Users & Enrollments ---
+    async getProfile() {
+        const response = await this.client.get('users/self/profile');
+        return response.data;
+    }
+    async getUser(userId) {
+        const response = await this.client.get(`users/${userId}`);
+        return response.data;
+    }
+    async searchUsers(accountId, searchTerm, enrollmentType) {
+        return this.getAllPages(`accounts/${accountId}/users`, {
+            search_term: searchTerm,
+            enrollment_type: enrollmentType,
+            per_page: 50
+        });
+    }
+    async listCourseEnrollments(courseId, type) {
+        return this.getAllPages(`courses/${courseId}/enrollments`, {
+            type,
+            include: ['user'],
+            per_page: 100
+        });
+    }
+    async enrollUser(courseId, userId, enrollmentType, notify) {
+        const response = await this.client.post(`courses/${courseId}/enrollments`, {
+            enrollment: {
+                user_id: userId,
+                type: enrollmentType,
+                enrollment_state: 'active',
+                notify: notify ?? false
+            }
+        });
+        return response.data;
+    }
+    async removeEnrollment(courseId, enrollmentId, task = 'conclude') {
+        const response = await this.client.delete(`courses/${courseId}/enrollments/${enrollmentId}`, { params: { task } });
+        return response.data;
+    }
+    // --- Student Submissions ---
+    async submitAssignmentFile(courseId, assignmentId, filePath, fileName, contentType) {
+        // Step 1: Pre-flight to get submission upload URL
+        const preflightResponse = await this.client.post(`courses/${courseId}/assignments/${assignmentId}/submissions/self/files`, { name: fileName, content_type: contentType });
+        const { upload_url, upload_params } = preflightResponse.data;
+        // Step 2: Upload file to storage
+        const fs = await import('node:fs');
+        const FormData = (await import('form-data')).default;
+        const form = new FormData();
+        Object.entries(upload_params).forEach(([key, value]) => {
+            form.append(key, value);
+        });
+        form.append('file', fs.createReadStream(filePath));
+        const uploadResponse = await axios.post(upload_url, form, {
+            headers: form.getHeaders(),
+            maxRedirects: 0,
+            validateStatus: (s) => s < 400
+        });
+        // Step 3: Confirm upload and get file ID
+        let fileId;
+        const location = uploadResponse.headers['location'] || uploadResponse.data?.location;
+        if (location) {
+            const confirmResponse = await this.client.get(location);
+            fileId = confirmResponse.data.id;
+        }
+        else {
+            fileId = uploadResponse.data.id;
+        }
+        // Step 4: Submit the assignment with the uploaded file
+        const submissionResponse = await this.client.post(`courses/${courseId}/assignments/${assignmentId}/submissions`, {
+            submission: {
+                submission_type: 'online_upload',
+                file_ids: [fileId]
+            }
+        });
+        return submissionResponse.data;
+    }
+    // --- Conversations ---
+    async listConversations(scope, perPage = 50) {
+        return this.getAllPages('conversations', {
+            scope: scope ?? 'inbox',
+            per_page: perPage
+        });
+    }
+    async getConversation(conversationId) {
+        const response = await this.client.get(`conversations/${conversationId}`);
+        return response.data;
+    }
+    async getConversationUnreadCount() {
+        const response = await this.client.get('conversations/unread_count');
+        return response.data;
+    }
+    async sendConversation(data) {
+        const payload = {
+            recipients: data.recipients,
+            subject: data.subject,
+            body: data.body,
+            group_conversation: data.group_conversation ?? false,
+            bulk_message: data.bulk_message ?? false
+        };
+        if (data.course_id) {
+            payload.context_code = `course_${data.course_id}`;
+        }
+        const response = await this.client.post('conversations', payload);
+        return response.data;
+    }
+    async replyToConversation(conversationId, body) {
+        const response = await this.client.post(`conversations/${conversationId}/add_message`, { body });
+        return response.data;
+    }
+    // --- Analytics ---
+    async getCourseAnalytics(courseId) {
+        const response = await this.client.get(`courses/${courseId}/analytics/activity`);
+        return response.data;
+    }
+    async getStudentAnalytics(courseId, studentId) {
+        const response = await this.client.get(`courses/${courseId}/analytics/users/${studentId}/activity`);
+        return response.data;
+    }
+    async getCourseActivityStream(courseId) {
+        const response = await this.client.get(`courses/${courseId}/activity_stream/summary`);
+        return response.data;
+    }
+    async searchCourseContent(courseId, query, contentTypes) {
+        const types = contentTypes && contentTypes.length > 0 ? contentTypes : ['assignments', 'pages', 'discussion_topics', 'quizzes', 'files'];
+        const results = [];
+        for (const type of types) {
+            try {
+                const items = await this.getAllPages(`courses/${courseId}/${type}`, { per_page: 50 });
+                const q = query.toLowerCase();
+                const matched = items.filter((i) => (i.name || i.title || '').toLowerCase().includes(q)).map((i) => ({ ...i, _content_type: type }));
+                results.push(...matched);
+            }
+            catch {
+                // skip types the user doesn't have access to
+            }
+        }
+        return results;
+    }
+    // --- Peer Reviews ---
+    async listPeerReviews(courseId, assignmentId) {
+        return this.getAllPages(`courses/${courseId}/assignments/${assignmentId}/peer_reviews`, { include: ['submission_comments', 'user'], per_page: 100 });
+    }
+    async getSubmissionPeerReviews(courseId, assignmentId, submissionId) {
+        return this.getAllPages(`courses/${courseId}/assignments/${assignmentId}/submissions/${submissionId}/peer_reviews`, { include: ['submission_comments', 'user'], per_page: 100 });
+    }
+    async createPeerReview(courseId, assignmentId, submissionId, revieweeId) {
+        const response = await this.client.post(`courses/${courseId}/assignments/${assignmentId}/submissions/${submissionId}/peer_reviews`, { user_id: revieweeId });
+        return response.data;
+    }
+    async deletePeerReview(courseId, assignmentId, submissionId, revieweeId) {
+        await this.client.delete(`courses/${courseId}/assignments/${assignmentId}/submissions/${submissionId}/peer_reviews`, { params: { user_id: revieweeId } });
+        return { deleted: true };
+    }
+    // --- New Quizzes (LTI) ---
+    async createNewQuiz(courseId, data) {
+        const response = await this.quizClient.post(`courses/${courseId}/quizzes`, data);
+        return response.data;
+    }
+    async updateNewQuiz(courseId, quizId, data) {
+        const response = await this.quizClient.patch(`courses/${courseId}/quizzes/${quizId}`, data);
+        return response.data;
+    }
+    async deleteNewQuiz(courseId, quizId) {
+        await this.quizClient.delete(`courses/${courseId}/quizzes/${quizId}`);
+        return { deleted: true };
+    }
+    async listNewQuizItems(courseId, quizId) {
+        const response = await this.quizClient.get(`courses/${courseId}/quizzes/${quizId}/items`);
+        return response.data.items ?? response.data ?? [];
+    }
+    async getNewQuizItem(courseId, quizId, itemId) {
+        const response = await this.quizClient.get(`courses/${courseId}/quizzes/${quizId}/items/${itemId}`);
+        return response.data;
+    }
+    async createNewQuizItem(courseId, quizId, data) {
+        const response = await this.quizClient.post(`courses/${courseId}/quizzes/${quizId}/items`, data);
+        return response.data;
+    }
+    async updateNewQuizItem(courseId, quizId, itemId, data) {
+        const response = await this.quizClient.patch(`courses/${courseId}/quizzes/${quizId}/items/${itemId}`, data);
+        return response.data;
+    }
+    async deleteNewQuizItem(courseId, quizId, itemId) {
+        await this.quizClient.delete(`courses/${courseId}/quizzes/${quizId}/items/${itemId}`);
+        return { deleted: true };
+    }
 }

package/dist/services/gemini-runner.js

@@ -0,0 +1,124 @@
+import { GoogleGenAI } from "@google/genai";
+const DEFAULT_MODEL = "gemini-2.5-flash";
+// Gemini no acepta: $schema, additionalProperties, anyOf multi-tipo, nullable
+function sanitizeSchema(schema) {
+    const { $schema, additionalProperties, nullable, ...clean } = schema;
+    // anyOf con un solo elemento → aplanar
+    if (Array.isArray(clean.anyOf) && clean.anyOf.length === 1) {
+        return sanitizeSchema(clean.anyOf[0]);
+    }
+    // anyOf con múltiples tipos (ej: number | string | null) → convertir a string
+    if (Array.isArray(clean.anyOf)) {
+        return { type: "string", description: clean.description ?? "" };
+    }
+    // type: ["string", "null"] → type: "string"
+    if (Array.isArray(clean.type)) {
+        clean.type = clean.type.find((t) => t !== "null") ?? "string";
+    }
+    if (clean.properties) {
+        const cleanProps = {};
+        for (const [k, v] of Object.entries(clean.properties)) {
+            cleanProps[k] = sanitizeSchema(v);
+        }
+        clean.properties = cleanProps;
+    }
+    if (clean.items) {
+        clean.items = sanitizeSchema(clean.items);
+    }
+    return clean;
+}
+function toolsToGemini(tools) {
+    const seen = new Set();
+    const unique = tools.filter(t => {
+        if (seen.has(t.tool.name))
+            return false;
+        seen.add(t.tool.name);
+        return true;
+    });
+    return [{
+            functionDeclarations: unique.map(t => ({
+                name: t.tool.name,
+                description: t.tool.description ?? "",
+                parameters: sanitizeSchema(t.tool.inputSchema)
+            }))
+        }];
+}
+export class GeminiRunner {
+    ai;
+    tools;
+    client;
+    constructor(apiKey, client, tools) {
+        this.ai = new GoogleGenAI({ apiKey });
+        this.client = client;
+        this.tools = tools;
+    }
+    async run(userMessage, options = {}) {
+        const model = options.model ?? DEFAULT_MODEL;
+        const geminiTools = toolsToGemini(this.tools);
+        const systemInstruction = options.systemPrompt ??
+            "Eres un asistente educativo con acceso a Canvas LMS. " +
+                "Usa las herramientas disponibles para responder sobre cursos, tareas, estudiantes y calificaciones. " +
+                "Responde SIEMPRE en español. Sé conciso y claro.";
+        const toolsUsed = [];
+        // Historial de conversación en formato Gemini
+        const contents = [
+            { role: "user", parts: [{ text: userMessage }] }
+        ];
+        // Agentic loop (máx. 10 iteraciones)
+        for (let i = 0; i < 10; i++) {
+            const response = await this.ai.models.generateContent({
+                model,
+                contents,
+                config: {
+                    tools: geminiTools,
+                    systemInstruction,
+                    thinkingConfig: { thinkingBudget: 0 } // deshabilitar thinking para evitar respuestas vacías
+                }
+            });
+            const candidate = response.candidates?.[0];
+            if (!candidate)
+                throw new Error("Gemini no devolvió ningún candidato.");
+            const parts = candidate.content?.parts ?? [];
+            // Agregar respuesta del modelo al historial
+            contents.push({ role: "model", parts });
+            // Separar texto y function calls
+            const functionCalls = parts.filter((p) => p.functionCall);
+            const textParts = parts.filter((p) => p.text);
+            // Sin function calls → respuesta final
+            if (functionCalls.length === 0) {
+                const answer = textParts.map((p) => p.text).join("").trim();
+                return { answer, tools_used: toolsUsed, model, provider: "gemini" };
+            }
+            // Ejecutar cada function call
+            const functionResponses = [];
+            for (const part of functionCalls) {
+                const { name, args } = part.functionCall;
+                const toolDef = this.tools.find(t => t.name === name);
+                let resultText;
+                if (!toolDef) {
+                    resultText = `Error: herramienta '${name}' no existe.`;
+                }
+                else {
+                    try {
+                        const result = await toolDef.handler(this.client, args ?? {});
+                        const blocks = result?.content ?? [];
+                        resultText = blocks
+                            .filter(b => b.type === "text" && b.text)
+                            .map(b => b.text)
+                            .join("\n");
+                        toolsUsed.push(name);
+                    }
+                    catch (err) {
+                        resultText = `Error: ${err instanceof Error ? err.message : String(err)}`;
+                    }
+                }
+                functionResponses.push({
+                    functionResponse: { name, response: { result: resultText } }
+                });
+            }
+            // Devolver resultados al modelo
+            contents.push({ role: "user", parts: functionResponses });
+        }
+        throw new Error("El agente excedió el límite de iteraciones (10).");
+    }
+}

package/dist/tools/analytics-tools.js

@@ -0,0 +1,118 @@
+import { resolveCourseId } from "../common/helpers.js";
+import { z } from "zod";
+export const analyticsTools = [
+    {
+        name: "canvas_get_course_analytics",
+        tool: {
+            name: "canvas_get_course_analytics",
+            description: "Get participation and activity analytics for a course (page views, participations per day)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    }
+                },
+                required: ["course_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({ course_id: z.union([z.number(), z.string()]) }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.getCourseAnalytics(courseId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_get_student_analytics",
+        tool: {
+            name: "canvas_get_student_analytics",
+            description: "Get activity analytics for a specific student in a course (page views, participations, tardiness breakdown)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    student_id: { type: "number", description: "The Canvas user ID of the student" }
+                },
+                required: ["course_id", "student_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                student_id: z.coerce.number()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.getStudentAnalytics(courseId, input.student_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_get_course_activity_stream",
+        tool: {
+            name: "canvas_get_course_activity_stream",
+            description: "Get a summary of recent activity in a course (submissions, discussions, announcements, etc.)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    }
+                },
+                required: ["course_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({ course_id: z.union([z.number(), z.string()]) }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.getCourseActivityStream(courseId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_search_course_content",
+        tool: {
+            name: "canvas_search_course_content",
+            description: "Search for content across a course by keyword (assignments, pages, discussions, quizzes, files)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    query: { type: "string", description: "Search keyword" },
+                    content_types: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Limit search to specific types: assignments, pages, discussion_topics, quizzes, files. Defaults to all."
+                    }
+                },
+                required: ["course_id", "query"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                query: z.string().min(1),
+                content_types: z.array(z.string()).optional()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.searchCourseContent(courseId, input.query, input.content_types);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    }
+];

package/dist/tools/assignment-tools.js

@@ -214,7 +214,7 @@ export const assignmentTools = [
                 student_id: z.coerce.number()
             }).parse(args);
             const courseId = await resolveCourseId(client, input.course_id);
-            const submission = await client.getSubmissionComments(courseId, input.assignment_id, input.student_id);
+            const submission = await client.getSingleSubmission(courseId, input.assignment_id, input.student_id);
             return {
                 content: [{ type: "text", text: JSON.stringify(submission.submission_comments || [], null, 2) }],
             };
@@ -518,6 +518,82 @@ export const assignmentTools = [
             };
         }
     },
+    {
+        name: "canvas_submit_assignment",
+        tool: {
+            name: "canvas_submit_assignment",
+            description: "Submit a file upload assignment as a student. Uploads a local file and creates the submission in one step.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    assignment_id: {
+                        type: "number",
+                        description: "The ID of the assignment to submit"
+                    },
+                    file_path: {
+                        type: "string",
+                        description: "Absolute local path to the file to submit (e.g. C:/Users/name/file.pdf)"
+                    },
+                    file_name: {
+                        type: "string",
+                        description: "File name to use in Canvas (e.g. MySubmission.pdf)"
+                    },
+                    content_type: {
+                        type: "string",
+                        description: "MIME type of the file (e.g. application/pdf)"
+                    }
+                },
+                required: ["course_id", "assignment_id", "file_path", "file_name", "content_type"]
+            }
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                assignment_id: z.coerce.number(),
+                file_path: z.string(),
+                file_name: z.string(),
+                content_type: z.string()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const submission = await client.submitAssignmentFile(courseId, input.assignment_id, input.file_path, input.file_name, input.content_type);
+            return {
+                content: [{ type: "text", text: JSON.stringify(submission, null, 2) }]
+            };
+        }
+    },
+    {
+        name: "canvas_delete_assignment",
+        tool: {
+            name: "canvas_delete_assignment",
+            description: "Delete an assignment from a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: {
+                        anyOf: [{ type: "number" }, { type: "string" }],
+                        description: "The ID or name of the course"
+                    },
+                    assignment_id: { type: "number", description: "The ID of the assignment to delete" }
+                },
+                required: ["course_id", "assignment_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.union([z.number(), z.string()]),
+                assignment_id: z.coerce.number()
+            }).parse(args);
+            const courseId = await resolveCourseId(client, input.course_id);
+            const result = await client.deleteAssignment(courseId, input.assignment_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
     {
         name: "canvas_update_assignment",
         tool: {