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

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: {

package/dist/tools/communication-tools.js

@@ -100,6 +100,107 @@ export const communicationTools = [
             };
         }
     },
+    {
+        name: "canvas_update_announcement",
+        tool: {
+            name: "canvas_update_announcement",
+            description: "Update the title or message of an existing announcement in a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: { type: "number", description: "The ID of the course" },
+                    topic_id: { type: "number", description: "The ID of the announcement (discussion topic)" },
+                    title: { type: "string", description: "New title for the announcement (optional)" },
+                    message: { type: "string", description: "New HTML message body for the announcement (optional)" },
+                },
+                required: ["course_id", "topic_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.coerce.number(),
+                topic_id: z.coerce.number(),
+                title: z.string().optional(),
+                message: z.string().optional(),
+            }).parse(args);
+            const fields = {};
+            if (input.title)
+                fields.title = input.title;
+            if (input.message)
+                fields.message = input.message;
+            const result = await client.updateAnnouncement(input.course_id, input.topic_id, fields);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_create_discussion",
+        tool: {
+            name: "canvas_create_discussion",
+            description: "Create a new discussion topic in a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: { type: "number", description: "The ID of the course" },
+                    title: { type: "string", description: "Title of the discussion" },
+                    message: { type: "string", description: "Body/message of the discussion" },
+                    discussion_type: {
+                        type: "string",
+                        enum: ["side_comment", "threaded"],
+                        description: "Discussion type (default: side_comment)"
+                    },
+                    published: { type: "boolean", description: "Whether to publish immediately (default: true)" },
+                    pinned: { type: "boolean", description: "Pin to top of discussion list" },
+                    require_initial_post: { type: "boolean", description: "Students must post before seeing replies" },
+                    allow_rating: { type: "boolean", description: "Allow students to rate posts" }
+                },
+                required: ["course_id", "title", "message"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.coerce.number(),
+                title: z.string(),
+                message: z.string(),
+                discussion_type: z.enum(["side_comment", "threaded"]).optional(),
+                published: z.boolean().optional(),
+                pinned: z.boolean().optional(),
+                require_initial_post: z.boolean().optional(),
+                allow_rating: z.boolean().optional()
+            }).parse(args);
+            const { course_id, ...data } = input;
+            const result = await client.createDiscussion(course_id, data);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_delete_discussion",
+        tool: {
+            name: "canvas_delete_discussion",
+            description: "Delete a discussion topic from a course",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    course_id: { type: "number", description: "The ID of the course" },
+                    topic_id: { type: "number", description: "The ID of the discussion topic to delete" }
+                },
+                required: ["course_id", "topic_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                course_id: z.coerce.number(),
+                topic_id: z.coerce.number()
+            }).parse(args);
+            const result = await client.deleteDiscussion(input.course_id, input.topic_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
     {
         name: "canvas_post_discussion_reply",
         tool: {

package/dist/tools/conversation-tools.js

@@ -0,0 +1,130 @@
+import { z } from "zod";
+export const conversationTools = [
+    {
+        name: "canvas_list_conversations",
+        tool: {
+            name: "canvas_list_conversations",
+            description: "List conversations (inbox messages) for the current user",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    scope: {
+                        type: "string",
+                        enum: ["inbox", "unread", "archived", "sent"],
+                        description: "Which mailbox to list (default: inbox)"
+                    }
+                },
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                scope: z.enum(["inbox", "unread", "archived", "sent"]).optional()
+            }).parse(args);
+            const result = await client.listConversations(input.scope);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_get_conversation",
+        tool: {
+            name: "canvas_get_conversation",
+            description: "Get a full conversation thread including all messages",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    conversation_id: { type: "number", description: "The ID of the conversation" }
+                },
+                required: ["conversation_id"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({ conversation_id: z.coerce.number() }).parse(args);
+            const result = await client.getConversation(input.conversation_id);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_get_conversation_unread_count",
+        tool: {
+            name: "canvas_get_conversation_unread_count",
+            description: "Get the number of unread messages in the inbox",
+            inputSchema: { type: "object", properties: {} },
+        },
+        handler: async (client, _args) => {
+            const result = await client.getConversationUnreadCount();
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_send_conversation",
+        tool: {
+            name: "canvas_send_conversation",
+            description: "Send a new message to one or more users (private message or course announcement)",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    recipients: {
+                        type: "array",
+                        items: { anyOf: [{ type: "number" }, { type: "string" }] },
+                        description: "Array of user IDs or login IDs to send the message to"
+                    },
+                    subject: { type: "string", description: "Message subject" },
+                    body: { type: "string", description: "Message body" },
+                    course_id: {
+                        type: "number",
+                        description: "Associate message with a course context (optional but recommended)"
+                    },
+                    group_conversation: {
+                        type: "boolean",
+                        description: "If true, all recipients share one thread. If false, each gets an individual message (default: false)"
+                    }
+                },
+                required: ["recipients", "subject", "body"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                recipients: z.array(z.union([z.coerce.number(), z.string()])),
+                subject: z.string(),
+                body: z.string(),
+                course_id: z.coerce.number().optional(),
+                group_conversation: z.boolean().optional()
+            }).parse(args);
+            const result = await client.sendConversation(input);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    },
+    {
+        name: "canvas_reply_to_conversation",
+        tool: {
+            name: "canvas_reply_to_conversation",
+            description: "Reply to an existing conversation thread",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    conversation_id: { type: "number", description: "The ID of the conversation to reply to" },
+                    body: { type: "string", description: "The reply message text" }
+                },
+                required: ["conversation_id", "body"],
+            },
+        },
+        handler: async (client, args) => {
+            const input = z.object({
+                conversation_id: z.coerce.number(),
+                body: z.string()
+            }).parse(args);
+            const result = await client.replyToConversation(input.conversation_id, input.body);
+            return {
+                content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+            };
+        }
+    }
+];