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

package/dist/index.js

@@ -23,6 +23,11 @@ import { configTools } from "./tools/config-tools.js";
 import { rubricTools } from "./tools/rubric-tools.js";
 import { calendarTools } from "./tools/calendar-tools.js";
 import { groupTools } from "./tools/group-tools.js";
+import { enrollmentTools } from "./tools/enrollment-tools.js";
+import { conversationTools } from "./tools/conversation-tools.js";
+import { newQuizTools } from "./tools/new-quiz-tools.js";
+import { analyticsTools } from "./tools/analytics-tools.js";
+import { peerReviewTools } from "./tools/peer-review-tools.js";
 import { canvasResources } from "./resources/canvas-resources.js";
 import { canvasPrompts } from "./prompts/canvas-prompts.js";
 import { startHttpServer } from "./http-server.js";
@@ -33,7 +38,7 @@ const program = new Command();
 program
     .name("canvas-mcp")
     .description("MCP Server for Canvas LMS (Refactored)")
-    .version("1.1.0");
+    .version("1.2.0");
 // --- CLI Commands ---
 program
     .command("config")
@@ -82,7 +87,7 @@ program
     const client = getClient();
     const server = new Server({
         name: "canvas-lms-server",
-        version: "1.0.0",
+        version: "1.2.0",
     }, {
         capabilities: {
             tools: {},
@@ -105,7 +110,12 @@ program
         ...configTools,
         ...rubricTools,
         ...calendarTools,
-        ...groupTools
+        ...groupTools,
+        ...enrollmentTools,
+        ...conversationTools,
+        ...newQuizTools,
+        ...analyticsTools,
+        ...peerReviewTools
     ];
     // --- Tool Handlers ---
     server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -163,6 +173,27 @@ program
     .action(async (options) => {
     const client = getClient();
     const port = Number.parseInt(options.port, 10);
-    await startHttpServer(client, options.host, port);
+    const allTools = [
+        ...courseTools,
+        ...assignmentTools,
+        ...quizTools,
+        ...gradingTools,
+        ...communicationTools,
+        ...studentTools,
+        ...quizQuestionTools,
+        ...createTools,
+        ...moduleTools,
+        ...fileTools,
+        ...configTools,
+        ...rubricTools,
+        ...calendarTools,
+        ...groupTools,
+        ...enrollmentTools,
+        ...conversationTools,
+        ...newQuizTools,
+        ...analyticsTools,
+        ...peerReviewTools
+    ];
+    await startHttpServer(client, options.host, port, allTools);
 });
 program.parse(process.argv);

package/dist/services/agent-runner.js

@@ -0,0 +1,214 @@
+import { Ollama } from "ollama";
+// ---------------------------------------------------------------------------
+// Detección de modo
+// ---------------------------------------------------------------------------
+async function detectMode(ollama, model, sampleTool) {
+    try {
+        await ollama.chat({
+            model,
+            messages: [{ role: "user", content: "ping" }],
+            tools: [sampleTool],
+            stream: false
+        });
+        return "native";
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg.includes("does not support tools"))
+            return "prompt";
+        throw err;
+    }
+}
+// ---------------------------------------------------------------------------
+// Parseo de tool calls en texto plano (modo prompt)
+// ---------------------------------------------------------------------------
+function parseTextToolCalls(content) {
+    const results = [];
+    const tagPattern = /<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/g;
+    let match;
+    while ((match = tagPattern.exec(content)) !== null) {
+        try {
+            const parsed = JSON.parse(match[1]);
+            if (parsed.name && parsed.arguments) {
+                results.push({ name: parsed.name, arguments: parsed.arguments });
+            }
+        }
+        catch { /* ignorar */ }
+    }
+    if (results.length > 0)
+        return results;
+    // Fallback: JSON suelto con "name" + "arguments"
+    const jsonPattern = /\{[\s\S]*?"name"\s*:\s*"([^"]+)"[\s\S]*?"arguments"\s*:\s*(\{[\s\S]*?\})\s*\}/g;
+    while ((match = jsonPattern.exec(content)) !== null) {
+        try {
+            results.push({ name: match[1], arguments: JSON.parse(match[2]) });
+        }
+        catch { /* ignorar */ }
+    }
+    return results;
+}
+// ---------------------------------------------------------------------------
+// System prompt para modo prompt-engineering
+// ---------------------------------------------------------------------------
+const PROMPT_MODE_TOOLS = [
+    "canvas_list_courses",
+    "canvas_get_assignments",
+    "canvas_get_assignment",
+    "canvas_list_students",
+    "canvas_list_students_with_grades",
+    "canvas_get_student_grades",
+    "canvas_list_modules",
+    "canvas_list_quizzes",
+    "canvas_get_submissions",
+    "canvas_get_submission",
+    "canvas_grade_submission",
+    "canvas_list_announcements",
+    "canvas_list_discussions",
+    "canvas_audit_course",
+    "canvas_list_assignment_groups",
+    "canvas_list_assignment_due_dates",
+    "canvas_grade_multiple_submissions",
+    "canvas_get_submission_comments",
+];
+function buildPromptSystemPrompt(tools) {
+    const selected = tools
+        .filter(t => PROMPT_MODE_TOOLS.includes(t.name))
+        .map(t => ({
+        name: t.tool.name,
+        description: t.tool.description,
+        parameters: t.tool.inputSchema
+    }));
+    return `Eres un asistente educativo con acceso a Canvas LMS.
+Responde SIEMPRE en español. Sé conciso y claro.
+
+Herramientas disponibles:
+${JSON.stringify(selected, null, 2)}
+
+REGLAS:
+1. Para consultar Canvas, responde SOLO con un bloque <tool_call>:
+<tool_call>
+{"name": "nombre_herramienta", "arguments": {"param": "valor"}}
+</tool_call>
+2. No escribas nada más cuando hagas una tool call.
+3. Después de recibir el resultado, responde al usuario en español.
+4. Una herramienta a la vez.`;
+}
+const NATIVE_SYSTEM = "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.";
+// ---------------------------------------------------------------------------
+// AgentRunner
+// ---------------------------------------------------------------------------
+export class AgentRunner {
+    ollama;
+    tools;
+    client;
+    ollamaTools;
+    constructor(client, tools, ollamaHost = "http://localhost:11434") {
+        this.client = client;
+        this.tools = tools;
+        this.ollama = new Ollama({ host: ollamaHost });
+        this.ollamaTools = tools.map(t => ({
+            type: "function",
+            function: {
+                name: t.tool.name,
+                description: t.tool.description ?? "",
+                parameters: t.tool.inputSchema
+            }
+        }));
+    }
+    async run(userMessage, options = {}) {
+        const modelRaw = options.model ?? "qwen2.5";
+        const modeArg = options.mode ?? "auto";
+        // Resolver nombre del modelo (fallback a :latest)
+        let model = modelRaw;
+        try {
+            await this.ollama.show({ model });
+        }
+        catch {
+            const withLatest = model.includes(":") ? model : `${model}:latest`;
+            try {
+                await this.ollama.show({ model: withLatest });
+                model = withLatest;
+            }
+            catch {
+                throw new Error(`Modelo '${modelRaw}' no encontrado en Ollama. Descárgalo con: ollama pull ${modelRaw}`);
+            }
+        }
+        // Detectar modo
+        let mode;
+        if (modeArg === "auto") {
+            mode = await detectMode(this.ollama, model, this.ollamaTools[0]);
+        }
+        else {
+            mode = modeArg;
+        }
+        const defaultSystem = mode === "prompt"
+            ? buildPromptSystemPrompt(this.tools)
+            : NATIVE_SYSTEM;
+        const messages = [{
+                role: "system",
+                content: options.systemPrompt ?? defaultSystem
+            }];
+        messages.push({ role: "user", content: userMessage });
+        const toolsUsed = [];
+        // Agentic loop (máx. 10 iteraciones para evitar loops infinitos)
+        for (let i = 0; i < 10; i++) {
+            const response = await this.ollama.chat({
+                model,
+                messages,
+                ...(mode === "native" ? { tools: this.ollamaTools } : {}),
+                stream: false
+            });
+            const assistantMessage = response.message;
+            messages.push(assistantMessage);
+            // Extraer tool calls
+            let calls = [];
+            if (mode === "native" && assistantMessage.tool_calls?.length) {
+                calls = assistantMessage.tool_calls.map(tc => ({
+                    name: tc.function.name,
+                    arguments: (tc.function.arguments ?? {})
+                }));
+            }
+            else if (mode === "prompt" && assistantMessage.content) {
+                calls = parseTextToolCalls(assistantMessage.content);
+            }
+            // Sin tool calls → respuesta final
+            if (calls.length === 0) {
+                const answer = (assistantMessage.content ?? "")
+                    .replace(/<tool_call>[\s\S]*?<\/tool_call>/g, "")
+                    .trim();
+                return { answer, tools_used: toolsUsed, model, mode };
+            }
+            // Ejecutar cada herramienta
+            for (const call of calls) {
+                const toolDef = this.tools.find(t => t.name === call.name);
+                let resultText;
+                if (!toolDef) {
+                    resultText = `Error: herramienta '${call.name}' no existe.`;
+                }
+                else {
+                    try {
+                        const result = await toolDef.handler(this.client, call.arguments);
+                        const blocks = result?.content ?? [];
+                        resultText = blocks
+                            .filter((b) => b.type === "text" && b.text)
+                            .map((b) => b.text)
+                            .join("\n");
+                        toolsUsed.push(call.name);
+                    }
+                    catch (err) {
+                        resultText = `Error: ${err instanceof Error ? err.message : String(err)}`;
+                    }
+                }
+                messages.push({
+                    role: mode === "native" ? "tool" : "user",
+                    content: mode === "native"
+                        ? `[${call.name}]\n${resultText}`
+                        : `Resultado de ${call.name}:\n${resultText}`
+                });
+            }
+        }
+        throw new Error("El agente excedió el límite de iteraciones (10).");
+    }
+}

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 };
+    }
 }