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

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`, {
@@ -268,9 +273,38 @@ export class CanvasClient {
         return response.data;
     }
     async updateModule(courseId, moduleId, data) {
-        const response = await this.client.put(`courses/${courseId}/modules/${moduleId}`, {
-            module: data
-        });
+        // Canvas only accepts arrays (prerequisite_module_ids, completion_requirements)
+        // via form-encoding, not JSON.
+        const hasArrays = data.prerequisite_module_ids !== undefined || data.completion_requirements !== undefined;
+        if (hasArrays) {
+            const params = new URLSearchParams();
+            if (data.name !== undefined)
+                params.set('module[name]', data.name);
+            if (data.published !== undefined)
+                params.set('module[published]', String(data.published));
+            if (data.position !== undefined)
+                params.set('module[position]', String(data.position));
+            if (data.require_sequential_progress !== undefined) {
+                params.set('module[require_sequential_progress]', String(data.require_sequential_progress));
+            }
+            if (data.prerequisite_module_ids) {
+                for (const id of data.prerequisite_module_ids) {
+                    params.append('module[prerequisite_module_ids][]', String(id));
+                }
+            }
+            if (data.completion_requirements) {
+                for (const req of data.completion_requirements) {
+                    params.append('module[completion_requirements][][id]', String(req.id));
+                    params.append('module[completion_requirements][][type]', req.type);
+                    if (req.min_score !== undefined) {
+                        params.append('module[completion_requirements][][min_score]', String(req.min_score));
+                    }
+                }
+            }
+            const response = await this.client.put(`courses/${courseId}/modules/${moduleId}`, params, { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } });
+            return response.data;
+        }
+        const response = await this.client.put(`courses/${courseId}/modules/${moduleId}`, { module: data });
         return response.data;
     }
     async deleteModule(courseId, moduleId) {
@@ -285,9 +319,20 @@ export class CanvasClient {
         return response.data;
     }
     async updateModuleItem(courseId, moduleId, itemId, data) {
-        const response = await this.client.put(`courses/${courseId}/modules/${moduleId}/items/${itemId}`, {
-            module_item: data
-        });
+        // Canvas only accepts completion_requirement via form-encoding, not JSON.
+        // Use URLSearchParams when completion_requirement is present.
+        if (data.completion_requirement) {
+            const params = new URLSearchParams();
+            params.set('module_item[completion_requirement][type]', data.completion_requirement.type);
+            const { completion_requirement, ...rest } = data;
+            for (const [key, value] of Object.entries(rest)) {
+                if (value !== undefined)
+                    params.set(`module_item[${key}]`, String(value));
+            }
+            const response = await this.client.put(`courses/${courseId}/modules/${moduleId}/items/${itemId}`, params, { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } });
+            return response.data;
+        }
+        const response = await this.client.put(`courses/${courseId}/modules/${moduleId}/items/${itemId}`, { module_item: data });
         return response.data;
     }
     async deleteModuleItem(courseId, moduleId, itemId) {
@@ -328,6 +373,39 @@ export class CanvasClient {
         }
         return uploadResponse.data;
     }
+    async getQuizSubmissions(courseId, quizId) {
+        const response = await this.client.get(`courses/${courseId}/quizzes/${quizId}/submissions`, {
+            params: { include: ['user'], per_page: 100 }
+        });
+        return response.data.quiz_submissions ?? [];
+    }
+    async deleteQuiz(courseId, quizId) {
+        await this.client.delete(`courses/${courseId}/quizzes/${quizId}`);
+        return { deleted: true };
+    }
+    async checkQuizPending(courseId, quizId) {
+        const [students, submissionsResp] = await Promise.all([
+            this.getEnrollments(courseId),
+            this.client.get(`courses/${courseId}/quizzes/${quizId}/submissions`, {
+                params: { per_page: 100 }
+            })
+        ]);
+        const realStudents = students.filter(u => u.name !== 'Estudiante de prueba' && u.sis_user_id !== null);
+        const submittedIds = new Set((submissionsResp.data.quiz_submissions ?? []).map((s) => s.user_id));
+        const pending = realStudents
+            .filter(u => !submittedIds.has(u.id))
+            .map(u => ({
+            id: u.id,
+            name: u.name ?? 'Desconocido',
+            email: u.login_id ?? ''
+        }));
+        return {
+            quiz_id: quizId,
+            total_students: realStudents.length,
+            submitted: submittedIds.size,
+            pending
+        };
+    }
     async createQuiz(courseId, quiz) {
         const response = await this.client.post(`courses/${courseId}/quizzes`, {
             quiz: quiz
@@ -378,6 +456,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 +473,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 +551,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) }],
+            };
+        }
+    }
+];