@lydt/geogebra-studio 0.0.0-stage → 0.4.0-rc.2

package/dist/tools/geogebra-tools.js

@@ -0,0 +1,3442 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geogebraTools = exports.instancePool = void 0;
+// import { MockGeoGebraInstance } from '../utils/geogebra-mock'; // Mock implementation for testing
+const geogebra_instance_1 = require("../utils/geogebra-instance"); // Real implementation (production)
+const logger_1 = __importDefault(require("../utils/logger"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const workspace_1 = require("../export/workspace");
+const validation_1 = require("../utils/validation");
+// Global instance pool for managing GeoGebra instances
+class GeoGebraInstancePool {
+    instances = new Map();
+    defaultInstance;
+    async getDefaultInstance() {
+        if (!this.defaultInstance) {
+            this.defaultInstance = new geogebra_instance_1.GeoGebraInstance({
+                appName: 'classic', // Use classic app for full functionality (from GEB-12 fixes)
+                width: 800,
+                height: 600,
+                showMenuBar: false,
+                showToolBar: false,
+                showAlgebraInput: false
+            });
+            try {
+                await this.defaultInstance.initialize(true); // Initialize in headless mode for production
+                logger_1.default.info('Default Real GeoGebra instance initialized');
+            }
+            catch (error) {
+                logger_1.default.error('Failed to initialize default GeoGebra instance', error);
+                this.defaultInstance = undefined;
+                throw error;
+            }
+        }
+        return this.defaultInstance;
+    }
+    async cleanup() {
+        if (this.defaultInstance) {
+            await this.defaultInstance.cleanup();
+            this.defaultInstance = undefined;
+        }
+        for (const instance of this.instances.values()) {
+            await instance.cleanup();
+        }
+        this.instances.clear();
+    }
+}
+exports.instancePool = new GeoGebraInstancePool();
+const DEFAULT_LINE_THICKNESS = 2;
+const DEFAULT_POINT_SIZE = 2;
+const LABEL_MODE_VALUES = ['all', 'none', 'points_only', 'specified'];
+function getWorkspaceDir() {
+    return (0, workspace_1.currentWorkspace)();
+}
+function getRequestedFilename(params) {
+    const filename = params['filename'];
+    const outputPath = params['outputPath'];
+    return filename || outputPath;
+}
+async function saveExportFile(instance, params, data, encoding) {
+    const requestedFilename = getRequestedFilename(params);
+    if (!requestedFilename) {
+        return undefined;
+    }
+    const workspaceDir = getWorkspaceDir();
+    const fullPath = instance.validateFilePath(requestedFilename, workspaceDir);
+    await fs_1.default.promises.mkdir(path_1.default.dirname(fullPath), { recursive: true });
+    if (encoding === 'base64') {
+        await fs_1.default.promises.writeFile(fullPath, Buffer.from(data, 'base64'));
+    }
+    else {
+        await fs_1.default.promises.writeFile(fullPath, data, encoding);
+    }
+    return fullPath;
+}
+async function applyLatexCaptionDefaults(instance, objectNames) {
+    if (objectNames.length === 0) {
+        return;
+    }
+    const captionCapableInstance = instance;
+    if (typeof captionCapableInstance.applyLatexCaptionDefaults !== 'function') {
+        return;
+    }
+    // Label visibility is controlled separately to support point-only / whitelist modes.
+    await captionCapableInstance.applyLatexCaptionDefaults(objectNames, false);
+}
+async function applyDefaultStyleSettings(instance, objectNames) {
+    if (objectNames.length === 0) {
+        return;
+    }
+    const styleCapableInstance = instance;
+    if (typeof styleCapableInstance.applyDefaultStyleSettings !== 'function') {
+        return;
+    }
+    await styleCapableInstance.applyDefaultStyleSettings(objectNames, DEFAULT_POINT_SIZE, DEFAULT_LINE_THICKNESS);
+}
+function normalizeVisibleLabels(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const labels = value
+        .filter((item) => typeof item === 'string')
+        .map(item => item.trim())
+        .filter(item => item.length > 0);
+    return Array.from(new Set(labels));
+}
+function parseLabelMode(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (LABEL_MODE_VALUES.includes(normalized)) {
+        return normalized;
+    }
+    return undefined;
+}
+async function setSingleLabelVisibility(instance, objectName, visible) {
+    await instance.callAppsApi('setLabelVisible', [objectName, visible]);
+}
+async function applyLabelVisibilityPolicy(instance, objectNames, options) {
+    if (objectNames.length === 0) {
+        return;
+    }
+    const uniqueNames = Array.from(new Set(objectNames.filter(name => name && name.trim())));
+    if (uniqueNames.length === 0) {
+        return;
+    }
+    const visibleSet = new Set(options.visibleLabels ?? []);
+    const failed = [];
+    for (const name of uniqueNames) {
+        try {
+            let visible = false;
+            if (options.mode === 'all') {
+                visible = true;
+            }
+            else if (options.mode === 'specified') {
+                visible = visibleSet.has(name);
+            }
+            else if (options.mode === 'points_only') {
+                const info = await instance.getObjectInfo(name);
+                visible = (info?.type?.toLowerCase() || '') === 'point';
+            }
+            else {
+                visible = false;
+            }
+            await setSingleLabelVisibility(instance, name, visible);
+        }
+        catch (_error) {
+            failed.push(name);
+        }
+    }
+    if (failed.length > 0) {
+        logger_1.default.warn(`Failed to apply label visibility for ${failed.length} object(s)`, {
+            failedObjects: failed,
+            labelMode: options.mode
+        });
+    }
+}
+async function applyObjectDefaults(instance, objectNames, labelOptions = { mode: 'points_only' }) {
+    if (objectNames.length === 0) {
+        return;
+    }
+    await applyLatexCaptionDefaults(instance, objectNames);
+    await applyDefaultStyleSettings(instance, objectNames);
+    await applyLabelVisibilityPolicy(instance, objectNames, labelOptions);
+}
+async function evalCommandWithLatexCaptionDefaults(instance, command) {
+    const labelCapableInstance = instance;
+    if (typeof labelCapableInstance.evalCommandGetLabels === 'function') {
+        const labels = await labelCapableInstance.evalCommandGetLabels(command);
+        await applyObjectDefaults(instance, labels);
+        return {
+            success: true,
+            labels
+        };
+    }
+    const fallbackResult = await instance.evalCommand(command);
+    if (!fallbackResult.success) {
+        return fallbackResult;
+    }
+    return {
+        ...fallbackResult,
+        labels: []
+    };
+}
+function buildPromptFramework(mode, task) {
+    const lines = [
+        `MODE: ${mode}`,
+        'Goal: Convert a geometry problem statement into reliable GeoGebra commands.',
+        '',
+        'Framework:',
+        '1) Extract entities and dependencies first (points, lines, circles, arcs, transformations).',
+        '2) Prefer dependency-based definitions over hard-coded coordinates when constraints are given.',
+        '3) Name intermediate objects explicitly (centers, radii, helper lines, helper points).',
+        '4) Build in small executable steps using geogebra_eval_commands.',
+        '5) After core geometry is valid, apply style commands (color, thickness, labels, visibility).',
+        '6) Export with geogebra_export_ggb.',
+        '',
+        'Output format requirement:',
+        '- Return pure command list, one command per line, no markdown fences, no prose.'
+    ];
+    if (task && task.trim()) {
+        lines.push('', 'Task:', task.trim());
+    }
+    lines.push('', 'Quality checklist:', '- Every derived point should be defined from prior objects.', '- Keep object relationships editable (sliders/rotations/midpoints remain live).', '- Avoid breaking constraints by arbitrary absolute coordinates unless explicitly required.', '- Keep labels minimal: hide labels for objects not explicitly required by the problem/figure.');
+    return lines.join('\n');
+}
+/**
+ * GeoGebra MCP Tools
+ */
+exports.geogebraTools = [
+    {
+        tool: {
+            name: 'geogebra_eval_command',
+            description: 'Execute a GeoGebra command and return the result',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    command: {
+                        type: 'string',
+                        description: 'The GeoGebra command to execute (e.g., "A = (1, 2)", "f(x) = x^2")'
+                    }
+                },
+                required: ['command']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const command = params['command'];
+                if (typeof command !== 'string' || !command.trim())
+                    throw new Error('command must be a nonempty string');
+                const instance = await exports.instancePool.getDefaultInstance();
+                const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: result.success,
+                                command,
+                                labels: result.labels,
+                                result: result.result,
+                                error: result.error
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to execute GeoGebra command', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_eval_commands',
+            description: 'Execute multiple GeoGebra commands sequentially in one call to reduce round-trip overhead',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    commands: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        description: 'GeoGebra commands to run in order (e.g., ["A=(0,0)", "B=(4,0)", "c=Circle(A,3)"])',
+                        minItems: 1
+                    },
+                    stopOnError: {
+                        type: 'boolean',
+                        description: 'Stop immediately when a command fails (default: true)'
+                    }
+                },
+                required: ['commands']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const commands = params['commands'];
+                const stopOnError = params['stopOnError'] !== undefined ? Boolean(params['stopOnError']) : true;
+                if (!Array.isArray(commands) || commands.length === 0) {
+                    throw new Error('commands must be a non-empty string array');
+                }
+                if (commands.length > 500) {
+                    throw new Error('Too many commands in one call. Maximum is 500');
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                const results = [];
+                for (let i = 0; i < commands.length; i++) {
+                    const command = commands[i];
+                    if (typeof command !== 'string' || !command.trim()) {
+                        results.push({
+                            index: i,
+                            command: String(command),
+                            success: false,
+                            error: 'Command must be a non-empty string'
+                        });
+                        if (stopOnError) {
+                            break;
+                        }
+                        continue;
+                    }
+                    const execution = await evalCommandWithLatexCaptionDefaults(instance, command);
+                    const commandResult = {
+                        index: i,
+                        command,
+                        success: execution.success
+                    };
+                    if (execution.result !== undefined) {
+                        commandResult.result = execution.result;
+                    }
+                    if (execution.labels !== undefined) {
+                        commandResult.result = commandResult.result === undefined
+                            ? { labels: execution.labels }
+                            : { output: commandResult.result, labels: execution.labels };
+                    }
+                    if (execution.error !== undefined) {
+                        commandResult.error = execution.error;
+                    }
+                    results.push(commandResult);
+                    if (!execution.success && stopOnError) {
+                        break;
+                    }
+                }
+                const successCount = results.filter(result => result.success).length;
+                const failureCount = results.length - successCount;
+                const completedAll = results.length === commands.length;
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: failureCount === 0,
+                                stopOnError,
+                                requested: commands.length,
+                                executed: results.length,
+                                completedAll,
+                                successCount,
+                                failureCount,
+                                results
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to execute batch commands', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_get_prompt_framework',
+            description: 'Get the built-in prompt framework for clients (Codex/Claude) to generate high-quality GeoGebra commands.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    task: {
+                        type: 'string',
+                        description: 'Optional problem statement to inject into the framework.'
+                    },
+                    mode: {
+                        type: 'string',
+                        enum: ['2D', '3D'],
+                        description: 'Target construction mode (default: 2D).'
+                    }
+                },
+                required: []
+            }
+        },
+        handler: async (params) => {
+            try {
+                const mode = (params['mode'] || '2D');
+                const task = params['task'];
+                const frameworkPrompt = buildPromptFramework(mode, task);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                mode,
+                                frameworkPrompt,
+                                recommendedWorkflow: [
+                                    'geogebra_clear_construction',
+                                    'geogebra_eval_commands',
+                                    'geogebra_export_ggb'
+                                ],
+                                notes: [
+                                    'This MCP does not require an extra server-side API key for generation.',
+                                    'Client models (Codex/Claude) should read this framework and generate command lists.'
+                                ]
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to return prompt framework', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_create_point',
+            description: 'Create a point in GeoGebra with specified coordinates',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'Name of the point (e.g., "A", "P1")'
+                    },
+                    x: {
+                        type: 'number',
+                        description: 'X coordinate of the point'
+                    },
+                    y: {
+                        type: 'number',
+                        description: 'Y coordinate of the point'
+                    },
+                    z: { type: 'number', description: 'Optional Z coordinate' }
+                },
+                required: ['name', 'x', 'y']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const name = params['name'];
+                const x = params['x'];
+                const y = params['y'];
+                // Validate parameters
+                const nameValidation = (0, validation_1.validateObjectName)(name);
+                if (!nameValidation.isValid) {
+                    throw new Error(`Invalid name: ${nameValidation.error}`);
+                }
+                const coordValidation = (0, validation_1.validateCoordinates)(x, y);
+                if (!coordValidation.isValid) {
+                    throw new Error(`Invalid coordinates: ${coordValidation.error}`);
+                }
+                const z = params['z'];
+                if (z !== undefined && (typeof z !== 'number' || !Number.isFinite(z)))
+                    throw new Error('Invalid z coordinate');
+                const command = z === undefined ? `${name} = (${x}, ${y})` : `${name} = (${x}, ${y}, ${z})`;
+                const instance = await exports.instancePool.getDefaultInstance();
+                const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+                if (result.success) {
+                    const pointInfo = await instance.getObjectInfo(name);
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    command,
+                                    point: pointInfo
+                                }, null, 2)
+                            }]
+                    };
+                }
+                else {
+                    throw new Error(result.error || 'Failed to create point');
+                }
+            }
+            catch (error) {
+                logger_1.default.error('Failed to create point', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_create_line',
+            description: 'Create a line in GeoGebra using two points or an equation. Provide either point1 and point2 parameters for two-point method, OR equation parameter for equation method.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'Name of the line (e.g., "l", "line1")'
+                    },
+                    point1: {
+                        type: 'string',
+                        description: 'Name of the first point (for two-point method). Optional if using equation method.'
+                    },
+                    point2: {
+                        type: 'string',
+                        description: 'Name of the second point (for two-point method). Optional if using equation method.'
+                    },
+                    equation: {
+                        type: 'string',
+                        description: 'Linear equation (e.g., "y = 2x + 3", "x + y = 5") for equation method. Optional if using two-point method.'
+                    }
+                },
+                required: ['name']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const name = params['name'];
+                const point1 = params['point1'];
+                const point2 = params['point2'];
+                const equation = params['equation'];
+                // Validate line name
+                const nameValidation = (0, validation_1.validateObjectName)(name);
+                if (!nameValidation.isValid) {
+                    throw new Error(`Invalid line name: ${nameValidation.error}`);
+                }
+                let command;
+                // Validate parameters based on method
+                if (point1 && point2) {
+                    // Two-point method - validate point names
+                    const point1Validation = (0, validation_1.validateObjectName)(point1);
+                    if (!point1Validation.isValid) {
+                        throw new Error(`Invalid first point name: ${point1Validation.error}`);
+                    }
+                    const point2Validation = (0, validation_1.validateObjectName)(point2);
+                    if (!point2Validation.isValid) {
+                        throw new Error(`Invalid second point name: ${point2Validation.error}`);
+                    }
+                    command = `${name} = Line(${point1}, ${point2})`;
+                }
+                else if (equation) {
+                    // Equation method - validate equation format
+                    const equationValidation = (0, validation_1.validateLinearEquation)(equation);
+                    if (!equationValidation.isValid) {
+                        throw new Error(`Invalid equation: ${equationValidation.error}`);
+                    }
+                    // For equation-based lines, we define them directly
+                    command = `${name}: ${equation}`;
+                }
+                else {
+                    throw new Error('Either provide two points or an equation for the line');
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+                if (result.success) {
+                    const lineInfo = await instance.getObjectInfo(name);
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    command,
+                                    line: lineInfo,
+                                    method: point1 && point2 ? 'two-point' : 'equation'
+                                }, null, 2)
+                            }]
+                    };
+                }
+                else {
+                    throw new Error(result.error || 'Failed to create line');
+                }
+            }
+            catch (error) {
+                logger_1.default.error('Failed to create line', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_create_circle',
+            description: 'Create a circle in GeoGebra with center and radius, or through three points. Provide either center and radius parameters for center-radius method, OR point1, point2, and point3 parameters for three-point method.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'Name of the circle (e.g., "c", "circle1")'
+                    },
+                    center: {
+                        type: 'string',
+                        description: 'Name of the center point (for center-radius method). Optional if using three-point method.'
+                    },
+                    radius: {
+                        type: 'number',
+                        description: 'Radius of the circle (for center-radius method). Optional if using three-point method.',
+                        minimum: 0
+                    },
+                    point1: {
+                        type: 'string',
+                        description: 'First point for three-point circle method. Optional if using center-radius method.'
+                    },
+                    point2: {
+                        type: 'string',
+                        description: 'Second point for three-point circle method. Optional if using center-radius method.'
+                    },
+                    point3: {
+                        type: 'string',
+                        description: 'Third point for three-point circle method. Optional if using center-radius method.'
+                    }
+                },
+                required: ['name']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const name = params['name'];
+                const center = params['center'];
+                const radius = params['radius'];
+                const point1 = params['point1'];
+                const point2 = params['point2'];
+                const point3 = params['point3'];
+                // Validate circle name
+                const nameValidation = (0, validation_1.validateObjectName)(name);
+                if (!nameValidation.isValid) {
+                    throw new Error(`Invalid circle name: ${nameValidation.error}`);
+                }
+                let command;
+                // Validate parameters based on method
+                if (center && radius !== undefined) {
+                    // Center-radius method
+                    const centerValidation = (0, validation_1.validateObjectName)(center);
+                    if (!centerValidation.isValid) {
+                        throw new Error(`Invalid center point name: ${centerValidation.error}`);
+                    }
+                    const radiusValidation = (0, validation_1.validateRadius)(radius);
+                    if (!radiusValidation.isValid) {
+                        throw new Error(`Invalid radius: ${radiusValidation.error}`);
+                    }
+                    command = `${name} = Circle(${center}, ${radius})`;
+                }
+                else if (point1 && point2 && point3) {
+                    // Three-point method - validate all point names
+                    const points = [
+                        { name: point1, label: 'first' },
+                        { name: point2, label: 'second' },
+                        { name: point3, label: 'third' }
+                    ];
+                    for (const point of points) {
+                        const pointValidation = (0, validation_1.validateObjectName)(point.name);
+                        if (!pointValidation.isValid) {
+                            throw new Error(`Invalid ${point.label} point name: ${pointValidation.error}`);
+                        }
+                    }
+                    command = `${name} = Circle(${point1}, ${point2}, ${point3})`;
+                }
+                else {
+                    throw new Error('Either provide center and radius, or three points for the circle');
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+                if (result.success) {
+                    const circleInfo = await instance.getObjectInfo(name);
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    command,
+                                    circle: circleInfo,
+                                    method: center && radius !== undefined ? 'center-radius' : 'three-point'
+                                }, null, 2)
+                            }]
+                    };
+                }
+                else {
+                    throw new Error(result.error || 'Failed to create circle');
+                }
+            }
+            catch (error) {
+                logger_1.default.error('Failed to create circle', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_create_polygon',
+            description: 'Create a polygon in GeoGebra with variable number of vertices',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'Name of the polygon (e.g., "poly", "triangle1")'
+                    },
+                    vertices: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        description: 'Array of point names that form the vertices of the polygon',
+                        minItems: 3
+                    }
+                },
+                required: ['name', 'vertices']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const name = params['name'];
+                const vertices = params['vertices'];
+                // Validate polygon name
+                const nameValidation = (0, validation_1.validateObjectName)(name);
+                if (!nameValidation.isValid) {
+                    throw new Error(`Invalid polygon name: ${nameValidation.error}`);
+                }
+                // Validate vertices
+                const verticesValidation = (0, validation_1.validatePolygonVertices)(vertices);
+                if (!verticesValidation.isValid) {
+                    throw new Error(verticesValidation.error);
+                }
+                const verticesStr = vertices.join(', ');
+                const command = `${name} = Polygon(${verticesStr})`;
+                const instance = await exports.instancePool.getDefaultInstance();
+                const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+                if (result.success) {
+                    const polygonInfo = await instance.getObjectInfo(name);
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    command,
+                                    polygon: polygonInfo,
+                                    vertexCount: vertices.length
+                                }, null, 2)
+                            }]
+                    };
+                }
+                else {
+                    throw new Error(result.error || 'Failed to create polygon');
+                }
+            }
+            catch (error) {
+                logger_1.default.error('Failed to create polygon', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_get_objects',
+            description: 'Get all objects in the current GeoGebra construction',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    type: {
+                        type: 'string',
+                        description: 'Optional: filter by object type. Use "all" for all objects, or specific types like "point", "line", "circle", "polygon", "function", "conic", etc.'
+                    }
+                },
+                required: []
+            }
+        },
+        handler: async (params) => {
+            try {
+                const type = params['type'];
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Handle the special case where type is "all" - GeoGebra API expects undefined for all objects
+                const typeFilter = (type === 'all') ? undefined : type;
+                const objectNames = await instance.getAllObjectNames(typeFilter);
+                const objects = [];
+                for (const name of objectNames) {
+                    const info = await instance.getObjectInfo(name);
+                    if (info) {
+                        objects.push(info);
+                    }
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                objectCount: objects.length,
+                                objects
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to get objects', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_clear_construction',
+            description: 'Clear all objects from the GeoGebra construction',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+                required: []
+            }
+        },
+        handler: async (_params) => {
+            try {
+                const instance = await exports.instancePool.getDefaultInstance();
+                await instance.newConstruction();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: 'Construction cleared successfully'
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to clear construction', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_instance_status',
+            description: 'Get the status of the GeoGebra instance',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+                required: []
+            }
+        },
+        handler: async (_params) => {
+            try {
+                const instance = await exports.instancePool.getDefaultInstance();
+                const isReady = await instance.isReady();
+                const state = instance.getState();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                status: {
+                                    isReady,
+                                    instanceId: state.id,
+                                    lastActivity: state.lastActivity,
+                                    config: state.config
+                                }
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to get instance status', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_auto_zoom',
+            description: 'Automatically calculate and set the optimal view to fit all visible objects with padding',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    padding: {
+                        type: 'number',
+                        description: 'Padding percentage around objects (default: 0.2 for 20% margin)'
+                    },
+                    minRange: {
+                        type: 'number',
+                        description: 'Minimum range for each axis (default: 2)'
+                    }
+                },
+                required: []
+            }
+        },
+        handler: async (params) => {
+            try {
+                const padding = params['padding'] ?? 0.2;
+                const minRange = params['minRange'] ?? 2;
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Get all objects
+                const objectNames = await instance.getAllObjectNames();
+                const allObjects = [];
+                for (const name of objectNames) {
+                    const info = await instance.getObjectInfo(name);
+                    if (info) {
+                        allObjects.push(info);
+                    }
+                }
+                // Filter visible points
+                const visiblePoints = allObjects.filter((obj) => obj.type === 'point' && obj.visible && obj.defined &&
+                    typeof obj.x === 'number' && typeof obj.y === 'number');
+                if (visiblePoints.length === 0) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: false,
+                                    error: 'No visible points found to calculate zoom'
+                                }, null, 2)
+                            }],
+                        isError: true
+                    };
+                }
+                // Calculate bounding box
+                let minX = Infinity;
+                let maxX = -Infinity;
+                let minY = Infinity;
+                let maxY = -Infinity;
+                for (const point of visiblePoints) {
+                    minX = Math.min(minX, point.x);
+                    maxX = Math.max(maxX, point.x);
+                    minY = Math.min(minY, point.y);
+                    maxY = Math.max(maxY, point.y);
+                }
+                // Calculate ranges
+                let rangeX = maxX - minX;
+                let rangeY = maxY - minY;
+                // Ensure minimum range
+                if (rangeX < minRange) {
+                    const center = (minX + maxX) / 2;
+                    minX = center - minRange / 2;
+                    maxX = center + minRange / 2;
+                    rangeX = minRange;
+                }
+                if (rangeY < minRange) {
+                    const center = (minY + maxY) / 2;
+                    minY = center - minRange / 2;
+                    maxY = center + minRange / 2;
+                    rangeY = minRange;
+                }
+                // Add padding
+                const padX = rangeX * padding;
+                const padY = rangeY * padding;
+                const viewXMin = minX - padX;
+                const viewXMax = maxX + padX;
+                const viewYMin = minY - padY;
+                const viewYMax = maxY + padY;
+                // Set the coordinate system
+                await instance.setCoordSystem(viewXMin, viewXMax, viewYMin, viewYMax);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: 'View automatically adjusted to fit all objects',
+                                pointsAnalyzed: visiblePoints.length,
+                                boundingBox: {
+                                    minX,
+                                    maxX,
+                                    minY,
+                                    maxY
+                                },
+                                viewRange: {
+                                    xmin: viewXMin,
+                                    xmax: viewXMax,
+                                    ymin: viewYMin,
+                                    ymax: viewYMax
+                                },
+                                padding: padding * 100 + '%'
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to auto-zoom', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_export_png',
+            description: 'Export the current GeoGebra construction as PNG with configurable dimensions, quality, and view settings',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    filename: {
+                        type: 'string',
+                        description: 'Output filename for the PNG file (e.g., "ellipse.png"). If provided, saves to file instead of returning base64.'
+                    },
+                    outputPath: {
+                        type: 'string',
+                        description: 'Alias of filename. Relative path inside workspace (e.g., "output/ellipse.png").'
+                    },
+                    scale: {
+                        type: 'number',
+                        description: 'Scale factor for the exported image (default: 1)'
+                    },
+                    width: {
+                        type: 'number',
+                        description: 'Width of the exported image in pixels'
+                    },
+                    height: {
+                        type: 'number',
+                        description: 'Height of the exported image in pixels'
+                    },
+                    transparent: {
+                        type: 'boolean',
+                        description: 'Whether the background should be transparent (default: false)'
+                    },
+                    dpi: {
+                        type: 'number',
+                        description: 'Dots per inch for the exported image (default: 72)'
+                    },
+                    xmin: {
+                        type: 'number',
+                        description: 'Minimum x-coordinate for view range'
+                    },
+                    xmax: {
+                        type: 'number',
+                        description: 'Maximum x-coordinate for view range'
+                    },
+                    ymin: {
+                        type: 'number',
+                        description: 'Minimum y-coordinate for view range'
+                    },
+                    ymax: {
+                        type: 'number',
+                        description: 'Maximum y-coordinate for view range'
+                    },
+                    showAxes: {
+                        type: 'boolean',
+                        description: 'Whether to show coordinate axes (default: true)'
+                    },
+                    showGrid: {
+                        type: 'boolean',
+                        description: 'Whether to show coordinate grid (default: false)'
+                    },
+                    autoZoom: {
+                        type: 'boolean',
+                        description: 'Automatically zoom to fit all visible objects before exporting (default: false)'
+                    },
+                    zoomPadding: {
+                        type: 'number',
+                        description: 'Padding percentage for auto-zoom (default: 0.2 for 20% margin)'
+                    },
+                    minRange: {
+                        type: 'number',
+                        description: 'Minimum range for each axis when auto-zooming (default: 2)'
+                    },
+                },
+                required: []
+            }
+        },
+        handler: async (params) => {
+            try {
+                // Input validation with safe defaults
+                const requestedFilename = getRequestedFilename(params);
+                let scale = params['scale'] || 1;
+                let width = params['width'];
+                let height = params['height'];
+                const transparent = params['transparent'] || false;
+                let dpi = params['dpi'] || 72;
+                let xmin = params['xmin'];
+                let xmax = params['xmax'];
+                let ymin = params['ymin'];
+                let ymax = params['ymax'];
+                const showAxes = params['showAxes'] !== undefined ? params['showAxes'] : true;
+                const showGrid = params['showGrid'] || false;
+                const autoZoom = params['autoZoom'] || false;
+                const zoomPadding = params['zoomPadding'] ?? 0.2;
+                const minRange = params['minRange'] ?? 2;
+                // Validate and clamp values for safety
+                if (scale !== undefined) {
+                    scale = Math.max(0.1, Math.min(10, scale));
+                }
+                if (width !== undefined) {
+                    width = Math.max(100, Math.min(5000, width));
+                }
+                if (height !== undefined) {
+                    height = Math.max(100, Math.min(5000, height));
+                }
+                if (dpi !== undefined) {
+                    dpi = Math.max(72, Math.min(300, dpi));
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Auto-zoom if requested (and manual coordinates not provided)
+                if (autoZoom && xmin === undefined && xmax === undefined && ymin === undefined && ymax === undefined) {
+                    const coords = await instance.calculateAutoZoomCoordinates(zoomPadding, minRange);
+                    if (coords) {
+                        xmin = coords.xmin;
+                        xmax = coords.xmax;
+                        ymin = coords.ymin;
+                        ymax = coords.ymax;
+                    }
+                }
+                // Apply view settings if specified or calculated by auto-zoom
+                if (xmin !== undefined && xmax !== undefined && ymin !== undefined && ymax !== undefined) {
+                    await instance.setCoordSystem(xmin, xmax, ymin, ymax);
+                }
+                if (params['showAxes'] !== undefined) {
+                    await instance.setAxesVisible(showAxes, showAxes);
+                }
+                if (params['showGrid'] !== undefined) {
+                    await instance.setGridVisible(showGrid);
+                }
+                // Export with enhanced parameters
+                const pngBase64 = await instance.exportPNG(scale, transparent, dpi, width, height);
+                const savedPath = await saveExportFile(instance, params, pngBase64, 'base64');
+                if (savedPath) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    format: 'PNG',
+                                    saved: true,
+                                    filename: savedPath,
+                                    scale,
+                                    width,
+                                    height,
+                                    transparent,
+                                    dpi,
+                                    viewSettings: {
+                                        coordSystem: (xmin !== undefined && xmax !== undefined && ymin !== undefined && ymax !== undefined) ? { xmin, xmax, ymin, ymax } : undefined,
+                                        showAxes,
+                                        showGrid
+                                    }
+                                }, null, 2)
+                            }]
+                    };
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                format: 'PNG',
+                                saveTarget: requestedFilename,
+                                scale,
+                                width,
+                                height,
+                                transparent,
+                                dpi,
+                                viewSettings: {
+                                    coordSystem: (xmin !== undefined && xmax !== undefined && ymin !== undefined && ymax !== undefined) ? { xmin, xmax, ymin, ymax } : undefined,
+                                    showAxes,
+                                    showGrid
+                                },
+                                data: pngBase64,
+                                encoding: 'base64'
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to export PNG', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_export_svg',
+            description: 'Export the current GeoGebra construction as SVG with configurable view settings',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    filename: {
+                        type: 'string',
+                        description: 'Output filename for the SVG file (e.g., "diagram.svg"). If provided, saves to file instead of returning SVG data.'
+                    },
+                    outputPath: {
+                        type: 'string',
+                        description: 'Alias of filename. Relative path inside workspace (e.g., "output/diagram.svg").'
+                    },
+                    xmin: {
+                        type: 'number',
+                        description: 'Minimum x-coordinate for view range'
+                    },
+                    xmax: {
+                        type: 'number',
+                        description: 'Maximum x-coordinate for view range'
+                    },
+                    ymin: {
+                        type: 'number',
+                        description: 'Minimum y-coordinate for view range'
+                    },
+                    ymax: {
+                        type: 'number',
+                        description: 'Maximum y-coordinate for view range'
+                    },
+                    showAxes: {
+                        type: 'boolean',
+                        description: 'Whether to show coordinate axes (default: true)'
+                    },
+                    showGrid: {
+                        type: 'boolean',
+                        description: 'Whether to show coordinate grid (default: false)'
+                    },
+                    autoZoom: {
+                        type: 'boolean',
+                        description: 'Automatically zoom to fit all visible objects before exporting (default: false)'
+                    },
+                    zoomPadding: {
+                        type: 'number',
+                        description: 'Padding percentage for auto-zoom (default: 0.2 for 20% margin)'
+                    }
+                },
+                required: []
+            }
+        },
+        handler: async (params) => {
+            try {
+                const requestedFilename = getRequestedFilename(params);
+                let xmin = params['xmin'];
+                let xmax = params['xmax'];
+                let ymin = params['ymin'];
+                let ymax = params['ymax'];
+                const showAxes = params['showAxes'] !== undefined ? params['showAxes'] : true;
+                const showGrid = params['showGrid'] || false;
+                const autoZoom = params['autoZoom'] || false;
+                const zoomPadding = params['zoomPadding'] ?? 0.2;
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Auto-zoom if requested (and manual coordinates not provided)
+                if (autoZoom && xmin === undefined && xmax === undefined && ymin === undefined && ymax === undefined) {
+                    const coords = await instance.calculateAutoZoomCoordinates(zoomPadding, 2);
+                    if (coords) {
+                        xmin = coords.xmin;
+                        xmax = coords.xmax;
+                        ymin = coords.ymin;
+                        ymax = coords.ymax;
+                    }
+                }
+                // Apply view settings if specified or calculated by auto-zoom
+                if (xmin !== undefined && xmax !== undefined && ymin !== undefined && ymax !== undefined) {
+                    await instance.setCoordSystem(xmin, xmax, ymin, ymax);
+                }
+                if (params['showAxes'] !== undefined) {
+                    await instance.setAxesVisible(showAxes, showAxes);
+                }
+                if (params['showGrid'] !== undefined) {
+                    await instance.setGridVisible(showGrid);
+                }
+                const svg = await instance.exportSVG();
+                const savedPath = await saveExportFile(instance, params, svg, 'utf8');
+                if (savedPath) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    format: 'SVG',
+                                    saved: true,
+                                    filename: savedPath,
+                                    viewSettings: {
+                                        coordSystem: (xmin !== undefined && xmax !== undefined && ymin !== undefined && ymax !== undefined) ? { xmin, xmax, ymin, ymax } : undefined,
+                                        showAxes,
+                                        showGrid
+                                    }
+                                }, null, 2)
+                            }]
+                    };
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                format: 'SVG',
+                                saveTarget: requestedFilename,
+                                viewSettings: {
+                                    coordSystem: (xmin !== undefined && xmax !== undefined && ymin !== undefined && ymax !== undefined) ? { xmin, xmax, ymin, ymax } : undefined,
+                                    showAxes,
+                                    showGrid
+                                },
+                                data: svg,
+                                encoding: 'utf8'
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to export SVG', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_export_pdf',
+            description: 'Export the current GeoGebra construction as PDF with optional direct file saving',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    filename: {
+                        type: 'string',
+                        description: 'Output filename for the PDF file (e.g., "diagram.pdf"). If provided, saves to file instead of returning base64.'
+                    },
+                    outputPath: {
+                        type: 'string',
+                        description: 'Alias of filename. Relative path inside workspace (e.g., "output/diagram.pdf").'
+                    },
+                    autoZoom: {
+                        type: 'boolean',
+                        description: 'Automatically zoom to fit all visible objects before exporting (default: false)'
+                    },
+                    zoomPadding: {
+                        type: 'number',
+                        description: 'Padding percentage for auto-zoom (default: 0.2 for 20% margin)'
+                    },
+                    minRange: {
+                        type: 'number',
+                        description: 'Minimum range for each axis when auto-zooming (default: 2)'
+                    },
+                },
+                required: []
+            }
+        },
+        handler: async (params) => {
+            try {
+                const requestedFilename = getRequestedFilename(params);
+                const autoZoom = params['autoZoom'] || false;
+                const zoomPadding = params['zoomPadding'] ?? 0.2;
+                const minRange = params['minRange'] ?? 2;
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Auto-zoom if requested
+                if (autoZoom) {
+                    await instance.applyAutoZoom(zoomPadding, minRange);
+                }
+                const pdfBase64 = await instance.exportPDF();
+                const savedPath = await saveExportFile(instance, params, pdfBase64, 'base64');
+                if (savedPath) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    format: 'PDF',
+                                    saved: true,
+                                    filename: savedPath
+                                }, null, 2)
+                            }]
+                    };
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                format: 'PDF',
+                                saveTarget: requestedFilename,
+                                data: pdfBase64,
+                                encoding: 'base64'
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to export PDF', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_export_ggb',
+            description: 'Export the current GeoGebra construction as a .ggb file with optional direct file saving',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    filename: {
+                        type: 'string',
+                        description: 'Output filename for the GGB file (e.g., "construction.ggb"). If provided, saves to file instead of returning base64.'
+                    },
+                    outputPath: {
+                        type: 'string',
+                        description: 'Alias of filename. Relative path inside workspace (e.g., "output/construction.ggb").'
+                    },
+                    autoZoom: {
+                        type: 'boolean',
+                        description: 'Automatically zoom to fit all visible objects before exporting (default: false)'
+                    },
+                    zoomPadding: {
+                        type: 'number',
+                        description: 'Padding percentage for auto-zoom (default: 0.2 for 20% margin)'
+                    },
+                    minRange: {
+                        type: 'number',
+                        description: 'Minimum range for each axis when auto-zooming (default: 2)'
+                    },
+                    labelMode: {
+                        type: 'string',
+                        enum: ['all', 'none', 'points_only', 'specified'],
+                        description: 'Label visibility mode before export (default: points_only).'
+                    },
+                    visibleLabels: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        description: 'Explicit label whitelist. If provided, only these labels are shown (equivalent to labelMode=specified).'
+                    },
+                    captionOverrides: {
+                        type: 'object',
+                        description: 'Optional captions keyed by object name. When supplied, unspecified objects use their names as labels.',
+                        additionalProperties: { type: 'string' }
+                    }
+                },
+                required: []
+            }
+        },
+        handler: async (params) => {
+            try {
+                const requestedFilename = getRequestedFilename(params);
+                const autoZoom = params['autoZoom'] || false;
+                const zoomPadding = params['zoomPadding'] ?? 0.2;
+                const minRange = params['minRange'] ?? 2;
+                const visibleLabels = normalizeVisibleLabels(params['visibleLabels']);
+                const parsedLabelMode = parseLabelMode(params['labelMode']);
+                const requestedLabelModeRaw = params['labelMode'];
+                if (requestedLabelModeRaw !== undefined && !parsedLabelMode) {
+                    throw new Error(`Invalid labelMode. Allowed values: ${LABEL_MODE_VALUES.join(', ')}`);
+                }
+                const labelOptions = visibleLabels.length > 0
+                    ? { mode: 'specified', visibleLabels }
+                    : { mode: parsedLabelMode ?? 'points_only' };
+                const captionOverrides = (params['captionOverrides'] ?? {});
+                const instance = await exports.instancePool.getDefaultInstance();
+                const allObjectNames = await instance.getAllObjectNames();
+                await applyObjectDefaults(instance, allObjectNames, labelOptions);
+                if (Object.keys(captionOverrides).length > 0) {
+                    for (const name of allObjectNames) {
+                        const hasCaption = Object.prototype.hasOwnProperty.call(captionOverrides, name);
+                        await instance.callAppsApi('setCaption', [name, hasCaption ? captionOverrides[name] : '']);
+                        await instance.callAppsApi('setLabelStyle', [name, hasCaption ? 3 : 0]);
+                    }
+                }
+                // Auto-zoom if requested
+                if (autoZoom) {
+                    await instance.applyAutoZoom(zoomPadding, minRange);
+                }
+                const ggbBase64 = await instance.exportGGB();
+                const savedPath = await saveExportFile(instance, params, ggbBase64, 'base64');
+                if (savedPath) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: true,
+                                    format: 'GGB',
+                                    saved: true,
+                                    filename: savedPath,
+                                    labelMode: labelOptions.mode,
+                                    visibleLabels: labelOptions.visibleLabels
+                                }, null, 2)
+                            }]
+                    };
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                format: 'GGB',
+                                saveTarget: requestedFilename,
+                                labelMode: labelOptions.mode,
+                                visibleLabels: labelOptions.visibleLabels,
+                                data: ggbBase64,
+                                encoding: 'base64'
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to export GGB', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    // Load GGB Tool
+    {
+        tool: {
+            name: 'geogebra_load_ggb',
+            description: 'Load a GeoGebra construction from a .ggb file or base64 data',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    source: {
+                        type: 'string',
+                        description: 'Either a file path to a .ggb file (e.g., "construction.ggb") or base64-encoded .ggb data'
+                    }
+                },
+                required: ['source']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const source = params['source'];
+                if (!source) {
+                    throw new Error('source parameter is required');
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Load the GGB file
+                await instance.loadGGB(source);
+                // Get all objects to confirm load
+                const objectNames = await instance.getAllObjectNames();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: 'GGB file loaded successfully',
+                                objectCount: objectNames.length,
+                                objects: objectNames
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to load GGB', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_plot_function',
+            description: 'Plot a mathematical function f(x) = expression with configurable domain and styling',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'Name of the function (e.g., "f", "g", "func1")'
+                    },
+                    expression: {
+                        type: 'string',
+                        description: 'Mathematical expression in terms of x (e.g., "x^2", "sin(x)", "2*x + 3")'
+                    },
+                    xMin: {
+                        type: 'number',
+                        description: 'Minimum x value for the domain (optional)'
+                    },
+                    xMax: {
+                        type: 'number',
+                        description: 'Maximum x value for the domain (optional)'
+                    },
+                    color: {
+                        type: 'string',
+                        description: 'Color of the function graph (hex, rgb, or color name)'
+                    },
+                    thickness: {
+                        type: 'number',
+                        description: 'Line thickness (1-10)',
+                        minimum: 1,
+                        maximum: 10
+                    },
+                    style: {
+                        type: 'string',
+                        description: 'Line style',
+                        enum: ['solid', 'dashed', 'dotted']
+                    }
+                },
+                required: ['name', 'expression']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const name = params['name'];
+                const expression = params['expression'];
+                const xMin = params['xMin'];
+                const xMax = params['xMax'];
+                const color = params['color'];
+                const thickness = params['thickness'];
+                const style = params['style'];
+                // Validate function name
+                const nameValidation = (0, validation_1.validateObjectName)(name);
+                if (!nameValidation.isValid) {
+                    throw new Error(`Invalid function name: ${nameValidation.error}`);
+                }
+                // Validate function expression
+                const exprValidation = (0, validation_1.validateFunctionExpression)(expression);
+                if (!exprValidation.isValid) {
+                    throw new Error(`Invalid expression: ${exprValidation.error}`);
+                }
+                // Validate domain if provided
+                if (xMin !== undefined && xMax !== undefined) {
+                    const domainValidation = (0, validation_1.validateDomainRange)(xMin, xMax, 'x');
+                    if (!domainValidation.isValid) {
+                        throw new Error(`Invalid domain: ${domainValidation.error}`);
+                    }
+                }
+                // Validate styling if provided
+                const styleValidation = (0, validation_1.validateFunctionStyling)(color, thickness, style);
+                if (!styleValidation.isValid) {
+                    throw new Error(`Invalid styling: ${styleValidation.error}`);
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Create the function
+                let command;
+                if (xMin !== undefined && xMax !== undefined) {
+                    // Function with domain restriction
+                    command = `${name}(x) = If(${xMin} <= x <= ${xMax}, ${expression}, ?)`;
+                }
+                else {
+                    // Standard function
+                    command = `${name}(x) = ${expression}`;
+                }
+                const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+                if (!result.success) {
+                    throw new Error(result.error || 'Failed to create function');
+                }
+                // Apply styling if provided
+                const styleCommands = [];
+                if (color) {
+                    styleCommands.push(`SetColor(${name}, "${color}")`);
+                }
+                if (thickness) {
+                    styleCommands.push(`SetLineThickness(${name}, ${thickness})`);
+                }
+                if (style && style !== 'solid') {
+                    const lineType = style === 'dashed' ? '10' : '20'; // GeoGebra line types
+                    styleCommands.push(`SetLineStyle(${name}, ${lineType})`);
+                }
+                // Execute styling commands
+                for (const styleCmd of styleCommands) {
+                    await instance.evalCommand(styleCmd);
+                }
+                const functionInfo = await instance.getObjectInfo(name);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                command,
+                                function: functionInfo,
+                                domain: (xMin !== undefined && xMax !== undefined) ? { xMin, xMax } : undefined,
+                                styling: {
+                                    color,
+                                    thickness,
+                                    style
+                                }
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to plot function', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_plot_parametric',
+            description: 'Plot a parametric curve defined by x(t) and y(t) with configurable parameter range and styling',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'Name of the parametric curve (e.g., "curve1", "c")'
+                    },
+                    xExpression: {
+                        type: 'string',
+                        description: 'X-coordinate expression in terms of parameter (e.g., "cos(t)", "t")'
+                    },
+                    yExpression: {
+                        type: 'string',
+                        description: 'Y-coordinate expression in terms of parameter (e.g., "sin(t)", "t^2")'
+                    },
+                    parameter: {
+                        type: 'string',
+                        description: 'Parameter variable name (default: "t")',
+                        default: 't'
+                    },
+                    tMin: {
+                        type: 'number',
+                        description: 'Minimum parameter value'
+                    },
+                    tMax: {
+                        type: 'number',
+                        description: 'Maximum parameter value'
+                    },
+                    color: {
+                        type: 'string',
+                        description: 'Color of the curve (hex, rgb, or color name)'
+                    },
+                    thickness: {
+                        type: 'number',
+                        description: 'Line thickness (1-10)',
+                        minimum: 1,
+                        maximum: 10
+                    },
+                    style: {
+                        type: 'string',
+                        description: 'Line style',
+                        enum: ['solid', 'dashed', 'dotted']
+                    }
+                },
+                required: ['name', 'xExpression', 'yExpression', 'tMin', 'tMax']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const name = params['name'];
+                const xExpression = params['xExpression'];
+                const yExpression = params['yExpression'];
+                const parameter = params['parameter'] || 't';
+                const tMin = params['tMin'];
+                const tMax = params['tMax'];
+                const color = params['color'];
+                const thickness = params['thickness'];
+                const style = params['style'];
+                // Validate curve name
+                const nameValidation = (0, validation_1.validateObjectName)(name);
+                if (!nameValidation.isValid) {
+                    throw new Error(`Invalid curve name: ${nameValidation.error}`);
+                }
+                // Validate parametric expressions
+                const exprValidation = (0, validation_1.validateParametricExpressions)(xExpression, yExpression, parameter);
+                if (!exprValidation.isValid) {
+                    throw new Error(`Invalid expressions: ${exprValidation.error}`);
+                }
+                // Validate parameter range
+                const rangeValidation = (0, validation_1.validateDomainRange)(tMin, tMax, parameter);
+                if (!rangeValidation.isValid) {
+                    throw new Error(`Invalid parameter range: ${rangeValidation.error}`);
+                }
+                // Validate styling if provided
+                const styleValidation = (0, validation_1.validateFunctionStyling)(color, thickness, style);
+                if (!styleValidation.isValid) {
+                    throw new Error(`Invalid styling: ${styleValidation.error}`);
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Create the parametric curve using GeoGebra's Curve command
+                const command = `${name} = Curve(${xExpression}, ${yExpression}, ${parameter}, ${tMin}, ${tMax})`;
+                const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+                if (!result.success) {
+                    throw new Error(result.error || 'Failed to create parametric curve');
+                }
+                // Apply styling if provided
+                const styleCommands = [];
+                if (color) {
+                    styleCommands.push(`SetColor(${name}, "${color}")`);
+                }
+                if (thickness) {
+                    styleCommands.push(`SetLineThickness(${name}, ${thickness})`);
+                }
+                if (style && style !== 'solid') {
+                    const lineType = style === 'dashed' ? '10' : '20';
+                    styleCommands.push(`SetLineStyle(${name}, ${lineType})`);
+                }
+                // Execute styling commands
+                for (const styleCmd of styleCommands) {
+                    await instance.evalCommand(styleCmd);
+                }
+                const curveInfo = await instance.getObjectInfo(name);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                command,
+                                curve: curveInfo,
+                                parametric: {
+                                    xExpression,
+                                    yExpression,
+                                    parameter,
+                                    range: { tMin, tMax }
+                                },
+                                styling: {
+                                    color,
+                                    thickness,
+                                    style
+                                }
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to plot parametric curve', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_plot_implicit',
+            description: 'Plot an implicit curve defined by F(x,y) = 0 with configurable styling',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'Name of the implicit curve (e.g., "implicit1", "curve")'
+                    },
+                    expression: {
+                        type: 'string',
+                        description: 'Implicit expression in terms of x and y (e.g., "x^2 + y^2 - 4", "x^2/4 + y^2/9 - 1")'
+                    },
+                    color: {
+                        type: 'string',
+                        description: 'Color of the curve (hex, rgb, or color name)'
+                    },
+                    thickness: {
+                        type: 'number',
+                        description: 'Line thickness (1-10)',
+                        minimum: 1,
+                        maximum: 10
+                    },
+                    style: {
+                        type: 'string',
+                        description: 'Line style',
+                        enum: ['solid', 'dashed', 'dotted']
+                    }
+                },
+                required: ['name', 'expression']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const name = params['name'];
+                const expression = params['expression'];
+                const color = params['color'];
+                const thickness = params['thickness'];
+                const style = params['style'];
+                // Validate curve name
+                const nameValidation = (0, validation_1.validateObjectName)(name);
+                if (!nameValidation.isValid) {
+                    throw new Error(`Invalid curve name: ${nameValidation.error}`);
+                }
+                // Validate implicit expression
+                const exprValidation = (0, validation_1.validateImplicitExpression)(expression);
+                if (!exprValidation.isValid) {
+                    throw new Error(`Invalid expression: ${exprValidation.error}`);
+                }
+                // Validate styling if provided
+                const styleValidation = (0, validation_1.validateFunctionStyling)(color, thickness, style);
+                if (!styleValidation.isValid) {
+                    throw new Error(`Invalid styling: ${styleValidation.error}`);
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Create the implicit curve using GeoGebra's ImplicitCurve command
+                const command = `${name} = ImplicitCurve(${expression})`;
+                const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+                if (!result.success) {
+                    throw new Error(result.error || 'Failed to create implicit curve');
+                }
+                // Apply styling if provided
+                const styleCommands = [];
+                if (color) {
+                    styleCommands.push(`SetColor(${name}, "${color}")`);
+                }
+                if (thickness) {
+                    styleCommands.push(`SetLineThickness(${name}, ${thickness})`);
+                }
+                if (style && style !== 'solid') {
+                    const lineType = style === 'dashed' ? '10' : '20';
+                    styleCommands.push(`SetLineStyle(${name}, ${lineType})`);
+                }
+                // Execute styling commands
+                for (const styleCmd of styleCommands) {
+                    await instance.evalCommand(styleCmd);
+                }
+                const curveInfo = await instance.getObjectInfo(name);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                command,
+                                curve: curveInfo,
+                                implicit: {
+                                    expression
+                                },
+                                styling: {
+                                    color,
+                                    thickness,
+                                    style
+                                }
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to plot implicit curve', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    // CAS (Computer Algebra System) Tools
+    {
+        tool: {
+            name: 'geogebra_solve_equation',
+            description: 'Solve algebraic equations using GeoGebra\'s CAS',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    equation: {
+                        type: 'string',
+                        description: 'The equation to solve (e.g., "x^2 - 4 = 0", "2x + 3 = 7")'
+                    },
+                    variable: {
+                        type: 'string',
+                        description: 'Variable to solve for (optional, defaults to automatic detection)'
+                    }
+                },
+                required: ['equation']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const equation = params['equation'];
+                const variable = params['variable'];
+                // Validate equation
+                const equationValidation = (0, validation_1.validateEquation)(equation);
+                if (!equationValidation.isValid) {
+                    throw new Error(`Invalid equation: ${equationValidation.error}`);
+                }
+                // Validate variable if provided
+                if (variable) {
+                    const variableValidation = (0, validation_1.validateVariableName)(variable);
+                    if (!variableValidation.isValid) {
+                        throw new Error(`Invalid variable: ${variableValidation.error}`);
+                    }
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Create the solve command
+                const command = variable ?
+                    `Solve(${equation}, ${variable})` :
+                    `Solve(${equation})`;
+                const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+                if (!result.success) {
+                    throw new Error(result.error || 'Failed to solve equation');
+                }
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                equation,
+                                variable: variable || 'auto-detected',
+                                command,
+                                solution: result.result
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to solve equation', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_solve_system',
+            description: 'Solve a system of equations using GeoGebra\'s CAS via algebraic substitution',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    equations: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        description: 'Array of equations to solve (e.g., ["x + y = 5", "x - y = 1"])'
+                    },
+                    variables: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        description: 'Variables to solve for (e.g., ["x", "y"])'
+                    }
+                },
+                required: ['equations', 'variables']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const equations = params['equations'];
+                const variables = params['variables'];
+                // Validate equations
+                const equationsValidation = (0, validation_1.validateSystemOfEquations)(equations);
+                if (!equationsValidation.isValid) {
+                    throw new Error(`Invalid equations: ${equationsValidation.error}`);
+                }
+                // Validate variables
+                const variablesValidation = (0, validation_1.validateVariablesList)(variables);
+                if (!variablesValidation.isValid) {
+                    throw new Error(`Invalid variables: ${variablesValidation.error}`);
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                // GEB-20 FIX: Implement algebraic substitution approach since Solve({equations}, {variables}) 
+                // syntax doesn't work in this GeoGebra version
+                if (equations.length === 2 && variables.length === 2) {
+                    // Handle 2x2 system using substitution method
+                    const [eq1, eq2] = equations;
+                    const [var1, var2] = variables;
+                    // Ensure we have valid equations and variables
+                    if (!eq1 || !eq2 || !var1 || !var2) {
+                        throw new Error('Invalid equations or variables provided');
+                    }
+                    // Parse equations to extract coefficients for linear systems
+                    // For now, implement a specific case for linear systems like:
+                    // x + y = 5, x - y = 1
+                    try {
+                        // Method 1: Try direct solve of individual equations
+                        // Convert equations to proper format and solve using simple Solve() command
+                        const cleanEq1 = eq1.trim();
+                        const cleanEq2 = eq2.trim();
+                        // For linear 2x2 systems, we can use algebraic manipulation
+                        // Example: x + y = 5 and x - y = 1
+                        // Add equations: 2x = 6, so x = 3
+                        // Subtract: 2y = 4, so y = 2
+                        if (cleanEq1.includes('+') && cleanEq2.includes('-') &&
+                            cleanEq1.includes('=') && cleanEq2.includes('=')) {
+                            // For x + y = 5 and x - y = 1:
+                            // Adding gives: (x + y) + (x - y) = 5 + 1 => 2x = 6
+                            // Subtracting gives: (x + y) - (x - y) = 5 - 1 => 2y = 4
+                            // Extract right-hand sides
+                            const rhs1 = cleanEq1.split('=')[1]?.trim();
+                            const rhs2 = cleanEq2.split('=')[1]?.trim();
+                            if (rhs1 && rhs2) {
+                                // Since Solve() doesn't work, use direct arithmetic calculation
+                                const sum = parseFloat(rhs1) + parseFloat(rhs2); // 5 + 1 = 6
+                                const diff = parseFloat(rhs1) - parseFloat(rhs2); // 5 - 1 = 4
+                                if (!isNaN(sum) && !isNaN(diff)) {
+                                    // Calculate solutions: x = sum/2, y = diff/2
+                                    const xSolution = sum / 2; // 6/2 = 3
+                                    const ySolution = diff / 2; // 4/2 = 2
+                                    // Create calculation objects to show the work
+                                    const sumObjectName = `sum_calc_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+                                    const diffObjectName = `diff_calc_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+                                    const xSolObjectName = `x_solution_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+                                    const ySolObjectName = `y_solution_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+                                    // Create arithmetic calculation objects in GeoGebra to verify
+                                    const sumCommand = `${sumObjectName} = ${rhs1} + ${rhs2}`;
+                                    const diffCommand = `${diffObjectName} = ${rhs1} - ${rhs2}`;
+                                    const xSolCommand = `${xSolObjectName} = ${sumObjectName} / 2`;
+                                    const ySolCommand = `${ySolObjectName} = ${diffObjectName} / 2`;
+                                    logger_1.default.info(`Arithmetic solution: ${sumCommand}, ${diffCommand}, ${xSolCommand}, ${ySolCommand}`);
+                                    // Execute the arithmetic calculations
+                                    const sumResult = await instance.evalCommand(sumCommand);
+                                    const diffResult = await instance.evalCommand(diffCommand);
+                                    const xSolResult = await instance.evalCommand(xSolCommand);
+                                    const ySolResult = await instance.evalCommand(ySolCommand);
+                                    if (sumResult.success && diffResult.success && xSolResult.success && ySolResult.success) {
+                                        // Get the calculated values to verify our arithmetic
+                                        const sumValue = await instance.getValueString(sumObjectName);
+                                        const diffValue = await instance.getValueString(diffObjectName);
+                                        const xSolValue = await instance.getValueString(xSolObjectName);
+                                        const ySolValue = await instance.getValueString(ySolObjectName);
+                                        // Clean up temporary calculation objects
+                                        await instance.deleteObject(sumObjectName);
+                                        await instance.deleteObject(diffObjectName);
+                                        await instance.deleteObject(xSolObjectName);
+                                        await instance.deleteObject(ySolObjectName);
+                                        // Build solution response
+                                        const parsedSolution = {};
+                                        parsedSolution[var1] = xSolution.toString();
+                                        parsedSolution[var2] = ySolution.toString();
+                                        const verificationSteps = {
+                                            step1: `Add equations: (${cleanEq1}) + (${cleanEq2}) → 2${var1} = ${sum}`,
+                                            step2: `Subtract equations: (${cleanEq1}) - (${cleanEq2}) → 2${var2} = ${diff}`,
+                                            step3: `Therefore: ${var1} = ${sum}/2 = ${xSolution}`,
+                                            step4: `Therefore: ${var2} = ${diff}/2 = ${ySolution}`
+                                        };
+                                        const geogebraVerification = {
+                                            sumCalculation: sumValue,
+                                            diffCalculation: diffValue,
+                                            xCalculation: xSolValue,
+                                            yCalculation: ySolValue
+                                        };
+                                        return {
+                                            content: [{
+                                                    type: 'text',
+                                                    text: JSON.stringify({
+                                                        success: true,
+                                                        equations,
+                                                        variables,
+                                                        method: 'arithmetic_calculation',
+                                                        solution: parsedSolution,
+                                                        verificationSteps,
+                                                        geogebraVerification,
+                                                        commands: [sumCommand, diffCommand, xSolCommand, ySolCommand],
+                                                        note: 'Solution calculated using direct arithmetic since GeoGebra Solve() commands are not supported in this version'
+                                                    }, null, 2)
+                                                }]
+                                        };
+                                    }
+                                }
+                            }
+                        }
+                        // Fallback: Try to solve using numerical approximation
+                        logger_1.default.info('Attempting fallback solution method');
+                        // Use simple substitution for well-known patterns
+                        if (cleanEq1.includes('x + y') && cleanEq2.includes('x - y')) {
+                            // Known pattern: x + y = a, x - y = b
+                            // Solution: x = (a + b)/2, y = (a - b)/2
+                            const eq1Parts = cleanEq1.split('=');
+                            const eq2Parts = cleanEq2.split('=');
+                            if (eq1Parts.length === 2 && eq2Parts.length === 2 && eq1Parts[1] && eq2Parts[1]) {
+                                const a = parseFloat(eq1Parts[1].trim());
+                                const b = parseFloat(eq2Parts[1].trim());
+                                if (!isNaN(a) && !isNaN(b)) {
+                                    const x = (a + b) / 2;
+                                    const y = (a - b) / 2;
+                                    const solutionMap = {};
+                                    solutionMap[var1] = x.toString();
+                                    solutionMap[var2] = y.toString();
+                                    return {
+                                        content: [{
+                                                type: 'text',
+                                                text: JSON.stringify({
+                                                    success: true,
+                                                    equations,
+                                                    variables,
+                                                    method: 'analytical_solution',
+                                                    solution: solutionMap,
+                                                    verification: `${var1} = ${x}, ${var2} = ${y}`
+                                                }, null, 2)
+                                            }]
+                                    };
+                                }
+                            }
+                        }
+                        // If all methods fail, provide a clear error message
+                        throw new Error('Unable to solve this system of equations. The GeoGebra instance may not support the required CAS operations for multi-variable systems. Consider solving manually or using simpler equation formats.');
+                    }
+                    catch (algebraError) {
+                        logger_1.default.error('Algebraic substitution failed', algebraError);
+                        throw new Error(`System solving failed: ${algebraError instanceof Error ? algebraError.message : String(algebraError)}`);
+                    }
+                }
+                else {
+                    // For non-2x2 systems, provide appropriate error
+                    throw new Error(`Currently only 2x2 linear systems are supported. Received ${equations.length} equations with ${variables.length} variables.`);
+                }
+            }
+            catch (error) {
+                logger_1.default.error('Failed to solve system of equations', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error),
+                                note: 'GEB-20 Fix: This version uses algebraic substitution instead of direct GeoGebra Solve() syntax which is not supported in this GeoGebra version.'
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_differentiate',
+            description: 'Compute the derivative of an expression using GeoGebra\'s CAS',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    expression: {
+                        type: 'string',
+                        description: 'The expression to differentiate (e.g., "x^2", "sin(x)", "x^3 + 2x + 1")'
+                    },
+                    variable: {
+                        type: 'string',
+                        description: 'Variable to differentiate with respect to (optional, defaults to "x")'
+                    }
+                },
+                required: ['expression']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const expression = params['expression'];
+                const variable = params['variable'] || 'x';
+                // Validate expression
+                const expressionValidation = (0, validation_1.validateAlgebraicExpression)(expression);
+                if (!expressionValidation.isValid) {
+                    throw new Error(`Invalid expression: ${expressionValidation.error}`);
+                }
+                // Validate variable
+                const variableValidation = (0, validation_1.validateVariableName)(variable);
+                if (!variableValidation.isValid) {
+                    throw new Error(`Invalid variable: ${variableValidation.error}`);
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Create a unique object name for the derivative result
+                const derivativeObjectName = `derivative_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+                // Create the derivative command with named object
+                const command = `${derivativeObjectName} = Derivative(${expression}, ${variable})`;
+                // Execute the command to create the derivative object
+                const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+                if (!result.success) {
+                    throw new Error(result.error || 'Failed to compute derivative');
+                }
+                // Check if the derivative object was created
+                const derivativeExists = await instance.exists(derivativeObjectName);
+                if (!derivativeExists) {
+                    throw new Error('Derivative object was not created - the expression may be invalid');
+                }
+                // Get the derivative value as a string
+                const derivativeValue = await instance.getValueString(derivativeObjectName);
+                // Clean up the temporary object
+                await instance.deleteObject(derivativeObjectName);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                expression,
+                                variable,
+                                command,
+                                derivative: derivativeValue
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to compute derivative', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_integrate',
+            description: 'Compute the integral of an expression using GeoGebra\'s CAS',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    expression: {
+                        type: 'string',
+                        description: 'The expression to integrate (e.g., "x^2", "sin(x)", "2x + 1")'
+                    },
+                    variable: {
+                        type: 'string',
+                        description: 'Variable to integrate with respect to (optional, defaults to "x")'
+                    }
+                },
+                required: ['expression']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const expression = params['expression'];
+                const variable = params['variable'] || 'x';
+                // Validate expression
+                const expressionValidation = (0, validation_1.validateAlgebraicExpression)(expression);
+                if (!expressionValidation.isValid) {
+                    throw new Error(`Invalid expression: ${expressionValidation.error}`);
+                }
+                // Validate variable
+                const variableValidation = (0, validation_1.validateVariableName)(variable);
+                if (!variableValidation.isValid) {
+                    throw new Error(`Invalid variable: ${variableValidation.error}`);
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Create a unique object name for the integral result
+                const integralObjectName = `integral_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+                // Create the integral command with named object
+                const command = `${integralObjectName} = Integral(${expression}, ${variable})`;
+                // Execute the command to create the integral object
+                const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+                if (!result.success) {
+                    throw new Error(result.error || 'Failed to compute integral');
+                }
+                // Check if the integral object was created
+                const integralExists = await instance.exists(integralObjectName);
+                if (!integralExists) {
+                    throw new Error('Integral object was not created - the expression may be invalid');
+                }
+                // Get the integral value as a string
+                const integralValue = await instance.getValueString(integralObjectName);
+                // Clean up the temporary object
+                await instance.deleteObject(integralObjectName);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                expression,
+                                variable,
+                                command,
+                                integral: integralValue
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to compute integral', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_simplify',
+            description: 'Simplify an algebraic expression using GeoGebra\'s CAS',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    expression: {
+                        type: 'string',
+                        description: 'The expression to simplify (e.g., "x^2 + 2x + 1", "(x+1)^2", "sin^2(x) + cos^2(x)")'
+                    }
+                },
+                required: ['expression']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const expression = params['expression'];
+                // Validate expression
+                const expressionValidation = (0, validation_1.validateAlgebraicExpression)(expression);
+                if (!expressionValidation.isValid) {
+                    throw new Error(`Invalid expression: ${expressionValidation.error}`);
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Create a unique object name for the simplified result
+                const simplifiedObjectName = `simplified_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+                // Create the simplify command with named object
+                const command = `${simplifiedObjectName} = Simplify(${expression})`;
+                // Execute the command to create the simplified object
+                const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+                if (!result.success) {
+                    throw new Error(result.error || 'Failed to simplify expression');
+                }
+                // Check if the simplified object was created
+                const simplifiedExists = await instance.exists(simplifiedObjectName);
+                if (!simplifiedExists) {
+                    throw new Error('Simplified object was not created - the expression may be invalid');
+                }
+                // Get the simplified value as a string
+                const simplifiedValue = await instance.getValueString(simplifiedObjectName);
+                // Clean up the temporary object
+                await instance.deleteObject(simplifiedObjectName);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                expression,
+                                command,
+                                simplified: simplifiedValue
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to simplify expression', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    // Animation Tools - GEB-7 Implementation
+    {
+        tool: {
+            name: 'geogebra_create_slider',
+            description: 'Create an interactive slider for parameter control and animation',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'Name of the slider (e.g., "a", "t", "speed")'
+                    },
+                    min: {
+                        type: 'number',
+                        description: 'Minimum value of the slider'
+                    },
+                    max: {
+                        type: 'number',
+                        description: 'Maximum value of the slider'
+                    },
+                    increment: {
+                        type: 'number',
+                        description: 'Step size for the slider (optional, defaults to 0.1)'
+                    },
+                    defaultValue: {
+                        type: 'number',
+                        description: 'Initial value of the slider (optional, defaults to minimum value)'
+                    },
+                    width: {
+                        type: 'number',
+                        description: 'Width of the slider in pixels (optional, defaults to 150)'
+                    },
+                    isAngle: {
+                        type: 'boolean',
+                        description: 'Whether the slider represents an angle (optional, defaults to false)'
+                    },
+                    horizontal: {
+                        type: 'boolean',
+                        description: 'Whether the slider is horizontal (optional, defaults to true)'
+                    }
+                },
+                required: ['name', 'min', 'max']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const name = params['name'];
+                const min = params['min'];
+                const max = params['max'];
+                const increment = params['increment'] || 0.1;
+                const defaultValue = params['defaultValue'] || min;
+                const width = params['width'] || 150;
+                const isAngle = params['isAngle'] || false;
+                const horizontal = params['horizontal'] !== false;
+                // Validate parameters
+                const validation = (0, validation_1.validateSliderParameters)(name, min, max, increment, defaultValue);
+                if (!validation.isValid) {
+                    throw new Error(validation.error);
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Create GeoGebra slider command
+                const command = `${name} = Slider(${min}, ${max}, ${increment}, 1, ${width}, ${isAngle}, ${horizontal}, false, false)`;
+                const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+                if (!result.success) {
+                    throw new Error(result.error || 'Failed to create slider');
+                }
+                // Set the default value
+                await instance.setValue(name, defaultValue);
+                const sliderInfo = await instance.getObjectInfo(name);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                command,
+                                slider: {
+                                    name,
+                                    min,
+                                    max,
+                                    increment,
+                                    currentValue: defaultValue,
+                                    width,
+                                    isAngle,
+                                    horizontal,
+                                    info: sliderInfo
+                                }
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to create slider', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_animate_parameter',
+            description: 'Configure an object (especially sliders) for parameter-based animation',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    objectName: {
+                        type: 'string',
+                        description: 'Name of the object to animate (typically a slider or point on a path)'
+                    },
+                    animate: {
+                        type: 'boolean',
+                        description: 'Whether to enable or disable animation for this object'
+                    },
+                    speed: {
+                        type: 'number',
+                        description: 'Animation speed (optional, defaults to 1, valid range: 0.1 to 10)'
+                    },
+                    direction: {
+                        type: 'string',
+                        enum: ['forward', 'backward', 'oscillating'],
+                        description: 'Animation direction (optional, defaults to "forward")'
+                    }
+                },
+                required: ['objectName', 'animate']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const objectName = params['objectName'];
+                const animate = params['animate'];
+                const speed = params['speed'] || 1;
+                const direction = params['direction'] || 'forward';
+                // Validate parameters
+                const nameValidation = (0, validation_1.validateObjectName)(objectName);
+                if (!nameValidation.isValid) {
+                    throw new Error(`Invalid object name: ${nameValidation.error}`);
+                }
+                const speedValidation = (0, validation_1.validateAnimationSpeed)(speed);
+                if (!speedValidation.isValid) {
+                    throw new Error(speedValidation.error);
+                }
+                const directionValidation = (0, validation_1.validateAnimationDirection)(direction);
+                if (!directionValidation.isValid) {
+                    throw new Error(directionValidation.error);
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Check if object exists
+                const exists = await instance.exists(objectName);
+                if (!exists) {
+                    throw new Error(`Object ${objectName} does not exist`);
+                }
+                // Set animation properties
+                await instance.setAnimating(objectName, animate);
+                if (animate) {
+                    await instance.setAnimationSpeed(objectName, speed);
+                }
+                const objectInfo = await instance.getObjectInfo(objectName);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                animation: {
+                                    objectName,
+                                    animate,
+                                    speed: animate ? speed : null,
+                                    direction,
+                                    objectInfo
+                                }
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to configure animation', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_trace_object',
+            description: 'Enable or disable trace for an object to visualize its path during animation',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    objectName: {
+                        type: 'string',
+                        description: 'Name of the object to trace (typically animated points or curves)'
+                    },
+                    enableTrace: {
+                        type: 'boolean',
+                        description: 'Whether to enable or disable tracing for this object'
+                    }
+                },
+                required: ['objectName', 'enableTrace']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const objectName = params['objectName'];
+                const enableTrace = params['enableTrace'];
+                // Validate object name
+                const nameValidation = (0, validation_1.validateObjectName)(objectName);
+                if (!nameValidation.isValid) {
+                    throw new Error(`Invalid object name: ${nameValidation.error}`);
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Check if object exists
+                const exists = await instance.exists(objectName);
+                if (!exists) {
+                    throw new Error(`Object ${objectName} does not exist`);
+                }
+                // Set trace
+                await instance.setTrace(objectName, enableTrace);
+                const objectInfo = await instance.getObjectInfo(objectName);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                trace: {
+                                    objectName,
+                                    enableTrace,
+                                    objectInfo
+                                }
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to set trace', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_start_animation',
+            description: 'Start animation for all objects with animation enabled',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+                required: []
+            }
+        },
+        handler: async (_params) => {
+            try {
+                const instance = await exports.instancePool.getDefaultInstance();
+                await instance.startAnimation();
+                const isRunning = await instance.isAnimationRunning();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                action: 'start_animation',
+                                isRunning
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to start animation', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_stop_animation',
+            description: 'Stop all currently running animations',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+                required: []
+            }
+        },
+        handler: async (_params) => {
+            try {
+                const instance = await exports.instancePool.getDefaultInstance();
+                await instance.stopAnimation();
+                const isRunning = await instance.isAnimationRunning();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                action: 'stop_animation',
+                                isRunning
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to stop animation', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_animation_status',
+            description: 'Check the current status of animations',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+                required: []
+            }
+        },
+        handler: async (_params) => {
+            try {
+                const instance = await exports.instancePool.getDefaultInstance();
+                const isRunning = await instance.isAnimationRunning();
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                action: 'check_animation_status',
+                                isRunning
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to check animation status', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_export_animation',
+            description: 'Export an animation as a sequence of frames for GIF creation',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    frameCount: {
+                        type: 'number',
+                        description: 'Number of frames to capture (default: 30, max: 300)'
+                    },
+                    frameDelay: {
+                        type: 'number',
+                        description: 'Delay between frames in milliseconds (default: 100)'
+                    },
+                    totalDuration: {
+                        type: 'number',
+                        description: 'Total animation duration in seconds (optional, calculated from frameCount and frameDelay if not provided)'
+                    },
+                    width: {
+                        type: 'number',
+                        description: 'Width of exported frames (optional, defaults to current view width)'
+                    },
+                    height: {
+                        type: 'number',
+                        description: 'Height of exported frames (optional, defaults to current view height)'
+                    },
+                    scale: {
+                        type: 'number',
+                        description: 'Scale factor for export quality (default: 1, range: 0.5 to 3)'
+                    },
+                    format: {
+                        type: 'string',
+                        enum: ['png', 'svg'],
+                        description: 'Export format for frames (default: png)'
+                    }
+                },
+                required: []
+            }
+        },
+        handler: async (params) => {
+            try {
+                const frameCount = params['frameCount'] || 30;
+                const frameDelay = params['frameDelay'] || 100;
+                const totalDuration = params['totalDuration'] || ((frameCount * frameDelay) / 1000);
+                const width = params['width'];
+                const height = params['height'];
+                const scale = Math.min(Math.max(params['scale'] || 1, 0.5), 3);
+                const format = params['format'] || 'png';
+                // Validate export parameters FIRST before any other operations
+                const validation = (0, validation_1.validateAnimationExportParameters)(frameCount, frameDelay, totalDuration);
+                if (!validation.isValid) {
+                    throw new Error(validation.error);
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                // GEB-17: Use the new enhanced exportAnimation method with better error handling
+                const frameRate = 1000 / frameDelay; // Convert delay to frame rate
+                const duration = totalDuration * 1000; // Convert to milliseconds
+                const animationOptions = {
+                    duration,
+                    frameRate,
+                    format: 'frames', // Always export as frames for now
+                    width,
+                    height
+                };
+                logger_1.default.info(`Starting animation export: ${frameCount} frames over ${totalDuration}s using enhanced method`);
+                // Use the enhanced exportAnimation method which includes all GEB-17 improvements
+                const frames = await instance.exportAnimation(animationOptions);
+                // Ensure we have the expected array of frames
+                if (!Array.isArray(frames)) {
+                    throw new Error('Animation export did not return frame array as expected');
+                }
+                logger_1.default.info(`Animation export completed: ${frames.length} frames captured`);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                export: {
+                                    frameCount: frames.length,
+                                    frameDelay,
+                                    totalDuration,
+                                    format,
+                                    scale,
+                                    dimensions: width && height ? { width, height } : null,
+                                    frames: frames.slice(0, 3), // Only return first 3 frames in response for brevity
+                                    note: `Captured ${frames.length} frames using enhanced GEB-17 export method. In a full implementation, these would be processed into a GIF file.`,
+                                    implementation_note: "Frame data contains base64 encoded images that can be processed into GIF format using libraries like 'gif-encoder' or 'gifski'",
+                                    geb17_improvements: "Enhanced with better error handling, applet validation, and retry logic"
+                                }
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to export animation', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error),
+                                geb17_note: "Enhanced error handling provides more detailed failure information"
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_animation_demo',
+            description: 'Create a comprehensive animation demonstration with parametric curves, traced objects, and animated sliders',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    demoType: {
+                        type: 'string',
+                        enum: ['parametric_spiral', 'pendulum', 'wave_function', 'circle_trace'],
+                        description: 'Type of animation demo to create (default: parametric_spiral)'
+                    },
+                    animationSpeed: {
+                        type: 'number',
+                        description: 'Animation speed (default: 1, range: 0.1 to 5)'
+                    }
+                },
+                required: []
+            }
+        },
+        handler: async (params) => {
+            try {
+                const demoType = params['demoType'] || 'parametric_spiral';
+                const animationSpeed = Math.min(Math.max(params['animationSpeed'] || 1, 0.1), 5);
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Clear any existing construction
+                await instance.newConstruction();
+                let createdObjects = [];
+                let animatedObjects = [];
+                switch (demoType) {
+                    case 'parametric_spiral':
+                        // Create time parameter slider
+                        await instance.evalCommand('t = Slider(0, 4*pi, 0.1, 1, 200, false, true, false, false)');
+                        await instance.setValue('t', 0);
+                        createdObjects.push('t');
+                        // Create parametric spiral
+                        await instance.evalCommand('spiralX(s) = s * cos(s)');
+                        await instance.evalCommand('spiralY(s) = s * sin(s)');
+                        await instance.evalCommand('spiral = Curve(spiralX(s), spiralY(s), s, 0, t)');
+                        createdObjects.push('spiral');
+                        // Create moving point on spiral
+                        await instance.evalCommand('P = (spiralX(t), spiralY(t))');
+                        createdObjects.push('P');
+                        // Enable animation and tracing
+                        await instance.setAnimating('t', true);
+                        await instance.setAnimationSpeed('t', animationSpeed);
+                        await instance.setTrace('P', true);
+                        animatedObjects.push('t');
+                        break;
+                    case 'pendulum':
+                        // Create angle slider
+                        await instance.evalCommand('angle = Slider(-pi/2, pi/2, 0.05, 1, 200, true, true, false, false)');
+                        await instance.setValue('angle', 0);
+                        createdObjects.push('angle');
+                        // Create pendulum setup
+                        await instance.evalCommand('origin = (0, 0)');
+                        await instance.evalCommand('length = 3');
+                        await instance.evalCommand('pendulumX = length * sin(angle)');
+                        await instance.evalCommand('pendulumY = -length * cos(angle)');
+                        await instance.evalCommand('bob = (pendulumX, pendulumY)');
+                        await instance.evalCommand('rod = Segment(origin, bob)');
+                        createdObjects.push('origin', 'bob', 'rod');
+                        // Enable animation and tracing
+                        await instance.setAnimating('angle', true);
+                        await instance.setAnimationSpeed('angle', animationSpeed);
+                        await instance.setTrace('bob', true);
+                        animatedObjects.push('angle');
+                        break;
+                    case 'wave_function':
+                        // Create time and frequency sliders
+                        await instance.evalCommand('time = Slider(0, 4*pi, 0.1, 1, 150, false, true, false, false)');
+                        await instance.evalCommand('freq = Slider(0.5, 3, 0.1, 1, 150, false, true, false, false)');
+                        await instance.setValue('time', 0);
+                        await instance.setValue('freq', 1);
+                        createdObjects.push('time', 'freq');
+                        // Create wave function
+                        await instance.evalCommand('wave(x) = sin(freq * x + time)');
+                        await instance.evalCommand('f = wave(x)');
+                        createdObjects.push('f');
+                        // Create a point that moves along the wave
+                        await instance.evalCommand('wavePoint = (time, sin(freq * time + time))');
+                        createdObjects.push('wavePoint');
+                        // Enable animation and tracing
+                        await instance.setAnimating('time', true);
+                        await instance.setAnimationSpeed('time', animationSpeed);
+                        await instance.setTrace('wavePoint', true);
+                        animatedObjects.push('time');
+                        break;
+                    case 'circle_trace':
+                        // Create angle slider
+                        await instance.evalCommand('theta = Slider(0, 4*pi, 0.1, 1, 200, true, true, false, false)');
+                        await instance.setValue('theta', 0);
+                        createdObjects.push('theta');
+                        // Create circles and tracing points
+                        await instance.evalCommand('radius1 = 2');
+                        await instance.evalCommand('radius2 = 1');
+                        await instance.evalCommand('center1 = (0, 0)');
+                        await instance.evalCommand('center2 = (radius1 * cos(theta), radius1 * sin(theta))');
+                        await instance.evalCommand('circle1 = Circle(center1, radius1)');
+                        await instance.evalCommand('circle2 = Circle(center2, radius2)');
+                        createdObjects.push('circle1', 'circle2', 'center1', 'center2');
+                        // Create epicycloid trace point
+                        await instance.evalCommand('traceX = (radius1 + radius2) * cos(theta) - radius2 * cos((radius1 + radius2) / radius2 * theta)');
+                        await instance.evalCommand('traceY = (radius1 + radius2) * sin(theta) - radius2 * sin((radius1 + radius2) / radius2 * theta)');
+                        await instance.evalCommand('tracePoint = (traceX, traceY)');
+                        createdObjects.push('tracePoint');
+                        // Enable animation and tracing
+                        await instance.setAnimating('theta', true);
+                        await instance.setAnimationSpeed('theta', animationSpeed);
+                        await instance.setTrace('tracePoint', true);
+                        await instance.setTrace('center2', true);
+                        animatedObjects.push('theta');
+                        break;
+                    default:
+                        throw new Error(`Unknown demo type: ${demoType}`);
+                }
+                // Set up coordinate system for better viewing
+                await instance.setCoordSystem(-6, 6, -6, 6);
+                await instance.setAxesVisible(true, true);
+                await instance.setGridVisible(true);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                demo: {
+                                    type: demoType,
+                                    animationSpeed,
+                                    createdObjects,
+                                    animatedObjects,
+                                    message: `Animation demo '${demoType}' created successfully!`,
+                                    instructions: [
+                                        'Use geogebra_start_animation to begin the animation',
+                                        'Use geogebra_stop_animation to pause it',
+                                        'Use geogebra_animation_status to check if it\'s running',
+                                        'Use geogebra_export_animation to capture frames for GIF creation',
+                                        'Objects with tracing enabled will show their paths during animation'
+                                    ]
+                                }
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to create animation demo', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    // Missing Tools Implementation
+    {
+        tool: {
+            name: 'geogebra_create_line_segment',
+            description: 'Create a line segment in GeoGebra between two points',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    name: {
+                        type: 'string',
+                        description: 'Name of the line segment (e.g., "AB", "segment1")'
+                    },
+                    point1: {
+                        type: 'string',
+                        description: 'Name of the first point'
+                    },
+                    point2: {
+                        type: 'string',
+                        description: 'Name of the second point'
+                    },
+                    color: {
+                        type: 'string',
+                        description: 'Color of the line segment (hex format, e.g., "#FF0000")'
+                    },
+                    thickness: {
+                        type: 'number',
+                        description: 'Thickness of the line segment (1-10)',
+                        minimum: 1,
+                        maximum: 10
+                    },
+                    style: {
+                        type: 'string',
+                        enum: ['solid', 'dashed', 'dotted'],
+                        description: 'Line style (default: solid)'
+                    }
+                },
+                required: ['name', 'point1', 'point2']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const name = params['name'];
+                const point1 = params['point1'];
+                const point2 = params['point2'];
+                const color = params['color'];
+                const thickness = params['thickness'];
+                const style = params['style'];
+                // Validate segment name
+                const nameValidation = (0, validation_1.validateObjectName)(name);
+                if (!nameValidation.isValid) {
+                    throw new Error(`Invalid segment name: ${nameValidation.error}`);
+                }
+                // Validate point names
+                const point1Validation = (0, validation_1.validateObjectName)(point1);
+                if (!point1Validation.isValid) {
+                    throw new Error(`Invalid first point name: ${point1Validation.error}`);
+                }
+                const point2Validation = (0, validation_1.validateObjectName)(point2);
+                if (!point2Validation.isValid) {
+                    throw new Error(`Invalid second point name: ${point2Validation.error}`);
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Create the line segment
+                const command = `${name} = Segment(${point1}, ${point2})`;
+                const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+                if (!result.success) {
+                    throw new Error(result.error || 'Failed to create line segment');
+                }
+                // Apply styling if provided
+                const styleCommands = [];
+                if (color) {
+                    styleCommands.push(`SetColor(${name}, "${color}")`);
+                }
+                if (thickness) {
+                    styleCommands.push(`SetLineThickness(${name}, ${thickness})`);
+                }
+                if (style && style !== 'solid') {
+                    const lineType = style === 'dashed' ? '10' : '20';
+                    styleCommands.push(`SetLineStyle(${name}, ${lineType})`);
+                }
+                // Execute styling commands
+                for (const styleCmd of styleCommands) {
+                    await instance.evalCommand(styleCmd);
+                }
+                const segmentInfo = await instance.getObjectInfo(name);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                command,
+                                segment: segmentInfo,
+                                styling: {
+                                    color,
+                                    thickness,
+                                    style
+                                }
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to create line segment', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    },
+    {
+        tool: {
+            name: 'geogebra_create_text',
+            description: 'Create a text object in GeoGebra with specified content and position',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    text: {
+                        type: 'string',
+                        description: 'Text content to display (can include GeoGebra expressions in quotes)'
+                    },
+                    x: {
+                        type: 'number',
+                        description: 'X coordinate for text position'
+                    },
+                    y: {
+                        type: 'number',
+                        description: 'Y coordinate for text position'
+                    },
+                    fontSize: {
+                        type: 'number',
+                        description: 'Font size in points (default: 12)',
+                        minimum: 8,
+                        maximum: 72
+                    },
+                    color: {
+                        type: 'string',
+                        description: 'Text color (hex format, e.g., "#000000")'
+                    },
+                    fontStyle: {
+                        type: 'string',
+                        enum: ['normal', 'bold', 'italic'],
+                        description: 'Font style (default: normal)'
+                    },
+                    name: {
+                        type: 'string',
+                        description: 'Optional name for the text object (auto-generated if not provided)'
+                    }
+                },
+                required: ['text', 'x', 'y']
+            }
+        },
+        handler: async (params) => {
+            try {
+                const text = params['text'];
+                const x = params['x'];
+                const y = params['y'];
+                const fontSize = params['fontSize'] || 12;
+                const color = params['color'];
+                const fontStyle = params['fontStyle'] || 'normal';
+                const name = params['name'] || `text_${Date.now()}`;
+                // Validate text object name
+                const nameValidation = (0, validation_1.validateObjectName)(name);
+                if (!nameValidation.isValid) {
+                    throw new Error(`Invalid text name: ${nameValidation.error}`);
+                }
+                // Validate coordinates
+                const coordValidation = (0, validation_1.validateCoordinates)(x, y);
+                if (!coordValidation.isValid) {
+                    throw new Error(`Invalid coordinates: ${coordValidation.error}`);
+                }
+                const instance = await exports.instancePool.getDefaultInstance();
+                // Format the text content properly for GeoGebra
+                let formattedText;
+                // If text is already quoted or contains dynamic expressions, use as-is
+                if ((text.startsWith('"') && text.endsWith('"')) || text.includes(' + ')) {
+                    formattedText = text;
+                }
+                else {
+                    // Otherwise, wrap static text in quotes
+                    formattedText = `"${text}"`;
+                }
+                // Create the text object
+                const command = `${name} = Text(${formattedText}, (${x}, ${y}))`;
+                const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+                if (!result.success) {
+                    throw new Error(result.error || 'Failed to create text');
+                }
+                // Apply styling if provided
+                const styleCommands = [];
+                if (color) {
+                    styleCommands.push(`SetColor(${name}, "${color}")`);
+                }
+                if (fontSize !== 12) {
+                    styleCommands.push(`SetTextSize(${name}, ${fontSize})`);
+                }
+                if (fontStyle !== 'normal') {
+                    const styleNumber = fontStyle === 'bold' ? '1' : fontStyle === 'italic' ? '2' : '0';
+                    styleCommands.push(`SetTextStyle(${name}, ${styleNumber})`);
+                }
+                // Execute styling commands
+                for (const styleCmd of styleCommands) {
+                    await instance.evalCommand(styleCmd);
+                }
+                const textInfo = await instance.getObjectInfo(name);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                command,
+                                textObject: textInfo,
+                                position: { x, y },
+                                styling: {
+                                    fontSize,
+                                    color,
+                                    fontStyle
+                                }
+                            }, null, 2)
+                        }]
+                };
+            }
+            catch (error) {
+                logger_1.default.error('Failed to create text', error);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: false,
+                                error: error instanceof Error ? error.message : String(error)
+                            }, null, 2)
+                        }],
+                    isError: true
+                };
+            }
+        }
+    }
+];
+//# sourceMappingURL=geogebra-tools.js.map