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

package/src/tools/geogebra-tools.ts

@@ -0,0 +1,3836 @@
+import { GeoGebraCommandResult } from '../types/geogebra';
+import { ToolDefinition } from '../types/mcp';
+// import { MockGeoGebraInstance } from '../utils/geogebra-mock'; // Mock implementation for testing
+import { GeoGebraInstance } from '../utils/geogebra-instance'; // Real implementation (production)
+import logger from '../utils/logger';
+import fs from 'fs';
+import path from 'path';
+import { currentWorkspace } from '../export/workspace';
+import { 
+  validateObjectName, 
+  validateCoordinates, 
+  validateRadius, 
+  validatePolygonVertices, 
+  validateLinearEquation,
+  validateFunctionExpression,
+  validateParametricExpressions,
+  validateImplicitExpression,
+  validateDomainRange,
+  validateFunctionStyling,
+  validateAlgebraicExpression,
+  validateEquation,
+  validateVariableName,
+  validateSystemOfEquations,
+  validateVariablesList,
+  validateSliderParameters,
+  validateAnimationSpeed,
+  validateAnimationDirection,
+  validateAnimationExportParameters
+} from '../utils/validation';
+
+// Global instance pool for managing GeoGebra instances
+class GeoGebraInstancePool {
+  private instances: Map<string, GeoGebraInstance> = new Map();
+  private defaultInstance: GeoGebraInstance | undefined;
+
+  async getDefaultInstance(): Promise<GeoGebraInstance> {
+    if (!this.defaultInstance) {
+      this.defaultInstance = new 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.info('Default Real GeoGebra instance initialized');
+      } catch (error) {
+        logger.error('Failed to initialize default GeoGebra instance', error);
+        this.defaultInstance = undefined;
+        throw error;
+      }
+    }
+    
+    return this.defaultInstance;
+  }
+
+  async cleanup(): Promise<void> {
+    if (this.defaultInstance) {
+      await this.defaultInstance.cleanup();
+      this.defaultInstance = undefined;
+    }
+    
+    for (const instance of this.instances.values()) {
+      await instance.cleanup();
+    }
+    this.instances.clear();
+  }
+}
+
+export const instancePool = new GeoGebraInstancePool();
+const DEFAULT_LINE_THICKNESS = 2;
+const DEFAULT_POINT_SIZE = 2;
+const LABEL_MODE_VALUES = ['all', 'none', 'points_only', 'specified'] as const;
+type LabelVisibilityMode = typeof LABEL_MODE_VALUES[number];
+
+interface LabelVisibilityOptions {
+  mode: LabelVisibilityMode;
+  visibleLabels?: string[];
+}
+
+function getWorkspaceDir(): string {
+  return currentWorkspace();
+}
+
+function getRequestedFilename(params: Record<string, unknown>): string | undefined {
+  const filename = params['filename'] as string | undefined;
+  const outputPath = params['outputPath'] as string | undefined;
+  return filename || outputPath;
+}
+
+async function saveExportFile(
+  instance: GeoGebraInstance,
+  params: Record<string, unknown>,
+  data: string,
+  encoding: 'base64' | BufferEncoding
+): Promise<string | undefined> {
+  const requestedFilename = getRequestedFilename(params);
+  if (!requestedFilename) {
+    return undefined;
+  }
+
+  const workspaceDir = getWorkspaceDir();
+  const fullPath = instance.validateFilePath(requestedFilename, workspaceDir);
+  await fs.promises.mkdir(path.dirname(fullPath), { recursive: true });
+
+  if (encoding === 'base64') {
+    await fs.promises.writeFile(fullPath, Buffer.from(data, 'base64'));
+  } else {
+    await fs.promises.writeFile(fullPath, data, encoding);
+  }
+
+  return fullPath;
+}
+
+async function applyLatexCaptionDefaults(
+  instance: GeoGebraInstance,
+  objectNames: string[]
+): Promise<void> {
+  if (objectNames.length === 0) {
+    return;
+  }
+
+  const captionCapableInstance = instance as unknown as {
+    applyLatexCaptionDefaults?: (names: string[], showLabel?: boolean) => Promise<void>;
+  };
+
+  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: GeoGebraInstance,
+  objectNames: string[]
+): Promise<void> {
+  if (objectNames.length === 0) {
+    return;
+  }
+
+  const styleCapableInstance = instance as unknown as {
+    applyDefaultStyleSettings?: (names: string[], pointSize: number, lineThickness: number) => Promise<void>;
+  };
+
+  if (typeof styleCapableInstance.applyDefaultStyleSettings !== 'function') {
+    return;
+  }
+
+  await styleCapableInstance.applyDefaultStyleSettings(
+    objectNames,
+    DEFAULT_POINT_SIZE,
+    DEFAULT_LINE_THICKNESS
+  );
+}
+
+function normalizeVisibleLabels(value: unknown): string[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  const labels = value
+    .filter((item): item is string => typeof item === 'string')
+    .map(item => item.trim())
+    .filter(item => item.length > 0);
+
+  return Array.from(new Set(labels));
+}
+
+function parseLabelMode(value: unknown): LabelVisibilityMode | undefined {
+  if (typeof value !== 'string') {
+    return undefined;
+  }
+
+  const normalized = value.trim().toLowerCase();
+  if ((LABEL_MODE_VALUES as readonly string[]).includes(normalized)) {
+    return normalized as LabelVisibilityMode;
+  }
+  return undefined;
+}
+
+async function setSingleLabelVisibility(
+  instance: GeoGebraInstance,
+  objectName: string,
+  visible: boolean
+): Promise<void> {
+  await instance.callAppsApi('setLabelVisible', [objectName, visible]);
+}
+
+async function applyLabelVisibilityPolicy(
+  instance: GeoGebraInstance,
+  objectNames: string[],
+  options: LabelVisibilityOptions
+): Promise<void> {
+  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: string[] = [];
+
+  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.warn(`Failed to apply label visibility for ${failed.length} object(s)`, {
+      failedObjects: failed,
+      labelMode: options.mode
+    });
+  }
+}
+
+async function applyObjectDefaults(
+  instance: GeoGebraInstance,
+  objectNames: string[],
+  labelOptions: LabelVisibilityOptions = { mode: 'points_only' }
+): Promise<void> {
+  if (objectNames.length === 0) {
+    return;
+  }
+
+  await applyLatexCaptionDefaults(instance, objectNames);
+  await applyDefaultStyleSettings(instance, objectNames);
+  await applyLabelVisibilityPolicy(instance, objectNames, labelOptions);
+}
+
+async function evalCommandWithLatexCaptionDefaults(
+  instance: GeoGebraInstance,
+  command: string
+): Promise<GeoGebraCommandResult> {
+  const labelCapableInstance = instance as unknown as {
+    evalCommandGetLabels?: (cmd: string) => Promise<string[]>;
+  };
+
+  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: '2D' | '3D', task?: string): string {
+  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
+ */
+export const geogebraTools: ToolDefinition[] = [
+  {
+    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'] as string;
+        if(typeof command !== 'string'||!command.trim())throw new Error('command must be a nonempty string');
+        const instance = await instancePool.getDefaultInstance();
+        
+        const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+        
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: result.success,
+              command,
+              labels: result.labels,
+              result: result.result,
+              error: result.error
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to execute GeoGebra command', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string[];
+        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 instancePool.getDefaultInstance();
+        const results: Array<{ index: number; command: string; success: boolean; result?: unknown; error?: string }> = [];
+
+        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: number; command: string; success: boolean; result?: unknown; error?: string } = {
+            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' as const,
+            text: JSON.stringify({
+              success: failureCount === 0,
+              stopOnError,
+              requested: commands.length,
+              executed: results.length,
+              completedAll,
+              successCount,
+              failureCount,
+              results
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to execute batch commands', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string | undefined) || '2D') as '2D' | '3D';
+        const task = params['task'] as string | undefined;
+        const frameworkPrompt = buildPromptFramework(mode, task);
+
+        return {
+          content: [{
+            type: 'text' as const,
+            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.error('Failed to return prompt framework', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string;
+        const x = params['x'] as number;
+        const y = params['y'] as number;
+        
+        // Validate parameters
+        const nameValidation = validateObjectName(name);
+        if (!nameValidation.isValid) {
+          throw new Error(`Invalid name: ${nameValidation.error}`);
+        }
+        
+        const coordValidation = 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 instancePool.getDefaultInstance();
+        
+        const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+        
+        if (result.success) {
+          const pointInfo = await instance.getObjectInfo(name);
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify({
+                success: true,
+                command,
+                point: pointInfo
+              }, null, 2)
+            }]
+          };
+        } else {
+          throw new Error(result.error || 'Failed to create point');
+        }
+      } catch (error) {
+        logger.error('Failed to create point', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string;
+        const point1 = params['point1'] as string | undefined;
+        const point2 = params['point2'] as string | undefined;
+        const equation = params['equation'] as string | undefined;
+        
+        // Validate line name
+        const nameValidation = validateObjectName(name);
+        if (!nameValidation.isValid) {
+          throw new Error(`Invalid line name: ${nameValidation.error}`);
+        }
+        
+        let command: string;
+        
+        // Validate parameters based on method
+        if (point1 && point2) {
+          // Two-point method - validate point names
+          const point1Validation = validateObjectName(point1);
+          if (!point1Validation.isValid) {
+            throw new Error(`Invalid first point name: ${point1Validation.error}`);
+          }
+          
+          const point2Validation = 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 = 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 instancePool.getDefaultInstance();
+        const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+        
+        if (result.success) {
+          const lineInfo = await instance.getObjectInfo(name);
+          return {
+            content: [{
+              type: 'text' as const,
+              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.error('Failed to create line', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string;
+        const center = params['center'] as string | undefined;
+        const radius = params['radius'] as number | undefined;
+        const point1 = params['point1'] as string | undefined;
+        const point2 = params['point2'] as string | undefined;
+        const point3 = params['point3'] as string | undefined;
+        
+        // Validate circle name
+        const nameValidation = validateObjectName(name);
+        if (!nameValidation.isValid) {
+          throw new Error(`Invalid circle name: ${nameValidation.error}`);
+        }
+        
+        let command: string;
+        
+        // Validate parameters based on method
+        if (center && radius !== undefined) {
+          // Center-radius method
+          const centerValidation = validateObjectName(center);
+          if (!centerValidation.isValid) {
+            throw new Error(`Invalid center point name: ${centerValidation.error}`);
+          }
+          
+          const radiusValidation = 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 = 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 instancePool.getDefaultInstance();
+        const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+        
+        if (result.success) {
+          const circleInfo = await instance.getObjectInfo(name);
+          return {
+            content: [{
+              type: 'text' as const,
+              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.error('Failed to create circle', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string;
+        const vertices = params['vertices'] as string[];
+        
+        // Validate polygon name
+        const nameValidation = validateObjectName(name);
+        if (!nameValidation.isValid) {
+          throw new Error(`Invalid polygon name: ${nameValidation.error}`);
+        }
+        
+        // Validate vertices
+        const verticesValidation = validatePolygonVertices(vertices);
+        if (!verticesValidation.isValid) {
+          throw new Error(verticesValidation.error);
+        }
+        
+        const verticesStr = vertices.join(', ');
+        const command = `${name} = Polygon(${verticesStr})`;
+        
+        const instance = await instancePool.getDefaultInstance();
+        const result = await evalCommandWithLatexCaptionDefaults(instance, command);
+        
+        if (result.success) {
+          const polygonInfo = await instance.getObjectInfo(name);
+          return {
+            content: [{
+              type: 'text' as const,
+              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.error('Failed to create polygon', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string | undefined;
+        const instance = await 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' as const,
+            text: JSON.stringify({
+              success: true,
+              objectCount: objects.length,
+              objects
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to get objects', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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 instancePool.getDefaultInstance();
+        await instance.newConstruction();
+        
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: true,
+              message: 'Construction cleared successfully'
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to clear construction', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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 instancePool.getDefaultInstance();
+        const isReady = await instance.isReady();
+        const state = instance.getState();
+        
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: true,
+              status: {
+                isReady,
+                instanceId: state.id,
+                lastActivity: state.lastActivity,
+                config: state.config
+              }
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to get instance status', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as number) ?? 0.2;
+        const minRange = (params['minRange'] as number) ?? 2;
+        
+        const instance = await 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: any) =>
+          obj.type === 'point' && obj.visible && obj.defined &&
+          typeof obj.x === 'number' && typeof obj.y === 'number'
+        );
+        
+        if (visiblePoints.length === 0) {
+          return {
+            content: [{
+              type: 'text' as const,
+              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' as const,
+            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.error('Failed to auto-zoom', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as number) || 1;
+        let width = params['width'] as number;
+        let height = params['height'] as number;
+        const transparent = (params['transparent'] as boolean) || false;
+        let dpi = (params['dpi'] as number) || 72;
+        let xmin = params['xmin'] as number;
+        let xmax = params['xmax'] as number;
+        let ymin = params['ymin'] as number;
+        let ymax = params['ymax'] as number;
+        const showAxes = params['showAxes'] !== undefined ? (params['showAxes'] as boolean) : true;
+        const showGrid = (params['showGrid'] as boolean) || false;
+        const autoZoom = (params['autoZoom'] as boolean) || false;
+        const zoomPadding = (params['zoomPadding'] as number) ?? 0.2;
+        const minRange = (params['minRange'] as number) ?? 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 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' as const,
+              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' as const,
+            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.error('Failed to export PNG', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as number;
+        let xmax = params['xmax'] as number;
+        let ymin = params['ymin'] as number;
+        let ymax = params['ymax'] as number;
+        const showAxes = params['showAxes'] !== undefined ? (params['showAxes'] as boolean) : true;
+        const showGrid = (params['showGrid'] as boolean) || false;
+        const autoZoom = (params['autoZoom'] as boolean) || false;
+        const zoomPadding = (params['zoomPadding'] as number) ?? 0.2;
+        
+        const instance = await 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' as const,
+              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' as const,
+            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.error('Failed to export SVG', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as boolean) || false;
+        const zoomPadding = (params['zoomPadding'] as number) ?? 0.2;
+        const minRange = (params['minRange'] as number) ?? 2;
+        
+        const instance = await 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' as const,
+              text: JSON.stringify({
+                success: true,
+                format: 'PDF',
+                saved: true,
+                filename: savedPath
+              }, null, 2)
+            }]
+          };
+        }
+        
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: true,
+              format: 'PDF',
+              saveTarget: requestedFilename,
+              data: pdfBase64,
+              encoding: 'base64'
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to export PDF', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as boolean) || false;
+        const zoomPadding = (params['zoomPadding'] as number) ?? 0.2;
+        const minRange = (params['minRange'] as number) ?? 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: LabelVisibilityOptions = visibleLabels.length > 0
+          ? { mode: 'specified', visibleLabels }
+          : { mode: parsedLabelMode ?? 'points_only' };
+        const captionOverrides = (params['captionOverrides'] ?? {}) as Record<string, string>;
+        
+        const instance = await 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' as const,
+              text: JSON.stringify({
+                success: true,
+                format: 'GGB',
+                saved: true,
+                filename: savedPath,
+                labelMode: labelOptions.mode,
+                visibleLabels: labelOptions.visibleLabels
+              }, null, 2)
+            }]
+          };
+        }
+        
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+                success: true,
+                format: 'GGB',
+                saveTarget: requestedFilename,
+                labelMode: labelOptions.mode,
+                visibleLabels: labelOptions.visibleLabels,
+                data: ggbBase64,
+                encoding: 'base64'
+              }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to export GGB', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string;
+        
+        if (!source) {
+          throw new Error('source parameter is required');
+        }
+        
+        const instance = await 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' as const,
+            text: JSON.stringify({
+              success: true,
+              message: 'GGB file loaded successfully',
+              objectCount: objectNames.length,
+              objects: objectNames
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to load GGB', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string;
+        const expression = params['expression'] as string;
+        const xMin = params['xMin'] as number | undefined;
+        const xMax = params['xMax'] as number | undefined;
+        const color = params['color'] as string | undefined;
+        const thickness = params['thickness'] as number | undefined;
+        const style = params['style'] as string | undefined;
+
+        // Validate function name
+        const nameValidation = validateObjectName(name);
+        if (!nameValidation.isValid) {
+          throw new Error(`Invalid function name: ${nameValidation.error}`);
+        }
+
+        // Validate function expression
+        const exprValidation = validateFunctionExpression(expression);
+        if (!exprValidation.isValid) {
+          throw new Error(`Invalid expression: ${exprValidation.error}`);
+        }
+
+        // Validate domain if provided
+        if (xMin !== undefined && xMax !== undefined) {
+          const domainValidation = validateDomainRange(xMin, xMax, 'x');
+          if (!domainValidation.isValid) {
+            throw new Error(`Invalid domain: ${domainValidation.error}`);
+          }
+        }
+
+        // Validate styling if provided
+        const styleValidation = validateFunctionStyling(color, thickness, style);
+        if (!styleValidation.isValid) {
+          throw new Error(`Invalid styling: ${styleValidation.error}`);
+        }
+
+        const instance = await instancePool.getDefaultInstance();
+
+        // Create the function
+        let command: string;
+        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: string[] = [];
+        
+        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' as const,
+            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.error('Failed to plot function', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string;
+        const xExpression = params['xExpression'] as string;
+        const yExpression = params['yExpression'] as string;
+        const parameter = (params['parameter'] as string) || 't';
+        const tMin = params['tMin'] as number;
+        const tMax = params['tMax'] as number;
+        const color = params['color'] as string | undefined;
+        const thickness = params['thickness'] as number | undefined;
+        const style = params['style'] as string | undefined;
+
+        // Validate curve name
+        const nameValidation = validateObjectName(name);
+        if (!nameValidation.isValid) {
+          throw new Error(`Invalid curve name: ${nameValidation.error}`);
+        }
+
+        // Validate parametric expressions
+        const exprValidation = validateParametricExpressions(xExpression, yExpression, parameter);
+        if (!exprValidation.isValid) {
+          throw new Error(`Invalid expressions: ${exprValidation.error}`);
+        }
+
+        // Validate parameter range
+        const rangeValidation = validateDomainRange(tMin, tMax, parameter);
+        if (!rangeValidation.isValid) {
+          throw new Error(`Invalid parameter range: ${rangeValidation.error}`);
+        }
+
+        // Validate styling if provided
+        const styleValidation = validateFunctionStyling(color, thickness, style);
+        if (!styleValidation.isValid) {
+          throw new Error(`Invalid styling: ${styleValidation.error}`);
+        }
+
+        const instance = await 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: string[] = [];
+        
+        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' as const,
+            text: JSON.stringify({
+              success: true,
+              command,
+              curve: curveInfo,
+              parametric: {
+                xExpression,
+                yExpression,
+                parameter,
+                range: { tMin, tMax }
+              },
+              styling: {
+                color,
+                thickness,
+                style
+              }
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to plot parametric curve', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string;
+        const expression = params['expression'] as string;
+        const color = params['color'] as string | undefined;
+        const thickness = params['thickness'] as number | undefined;
+        const style = params['style'] as string | undefined;
+
+        // Validate curve name
+        const nameValidation = validateObjectName(name);
+        if (!nameValidation.isValid) {
+          throw new Error(`Invalid curve name: ${nameValidation.error}`);
+        }
+
+        // Validate implicit expression
+        const exprValidation = validateImplicitExpression(expression);
+        if (!exprValidation.isValid) {
+          throw new Error(`Invalid expression: ${exprValidation.error}`);
+        }
+
+        // Validate styling if provided
+        const styleValidation = validateFunctionStyling(color, thickness, style);
+        if (!styleValidation.isValid) {
+          throw new Error(`Invalid styling: ${styleValidation.error}`);
+        }
+
+        const instance = await 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: string[] = [];
+        
+        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' as const,
+            text: JSON.stringify({
+              success: true,
+              command,
+              curve: curveInfo,
+              implicit: {
+                expression
+              },
+              styling: {
+                color,
+                thickness,
+                style
+              }
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to plot implicit curve', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string;
+        const variable = params['variable'] as string | undefined;
+
+        // Validate equation
+        const equationValidation = validateEquation(equation);
+        if (!equationValidation.isValid) {
+          throw new Error(`Invalid equation: ${equationValidation.error}`);
+        }
+
+        // Validate variable if provided
+        if (variable) {
+          const variableValidation = validateVariableName(variable);
+          if (!variableValidation.isValid) {
+            throw new Error(`Invalid variable: ${variableValidation.error}`);
+          }
+        }
+
+        const instance = await 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' as const,
+            text: JSON.stringify({
+              success: true,
+              equation,
+              variable: variable || 'auto-detected',
+              command,
+              solution: result.result
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to solve equation', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string[];
+        const variables = params['variables'] as string[];
+
+        // Validate equations
+        const equationsValidation = validateSystemOfEquations(equations);
+        if (!equationsValidation.isValid) {
+          throw new Error(`Invalid equations: ${equationsValidation.error}`);
+        }
+
+        // Validate variables
+        const variablesValidation = validateVariablesList(variables);
+        if (!variablesValidation.isValid) {
+          throw new Error(`Invalid variables: ${variablesValidation.error}`);
+        }
+
+        const instance = await 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.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: Record<string, string> = {};
+                    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' as const,
+                        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.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: Record<string, string> = {};
+                  solutionMap[var1] = x.toString();
+                  solutionMap[var2] = y.toString();
+                  
+                  return {
+                    content: [{
+                      type: 'text' as const,
+                      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.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.error('Failed to solve system of equations', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string;
+        const variable = (params['variable'] as string) || 'x';
+
+        // Validate expression
+        const expressionValidation = validateAlgebraicExpression(expression);
+        if (!expressionValidation.isValid) {
+          throw new Error(`Invalid expression: ${expressionValidation.error}`);
+        }
+
+        // Validate variable
+        const variableValidation = validateVariableName(variable);
+        if (!variableValidation.isValid) {
+          throw new Error(`Invalid variable: ${variableValidation.error}`);
+        }
+
+        const instance = await 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' as const,
+            text: JSON.stringify({
+              success: true,
+              expression,
+              variable,
+              command,
+              derivative: derivativeValue
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to compute derivative', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string;
+        const variable = (params['variable'] as string) || 'x';
+
+        // Validate expression
+        const expressionValidation = validateAlgebraicExpression(expression);
+        if (!expressionValidation.isValid) {
+          throw new Error(`Invalid expression: ${expressionValidation.error}`);
+        }
+
+        // Validate variable
+        const variableValidation = validateVariableName(variable);
+        if (!variableValidation.isValid) {
+          throw new Error(`Invalid variable: ${variableValidation.error}`);
+        }
+
+        const instance = await 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' as const,
+            text: JSON.stringify({
+              success: true,
+              expression,
+              variable,
+              command,
+              integral: integralValue
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to compute integral', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string;
+
+        // Validate expression
+        const expressionValidation = validateAlgebraicExpression(expression);
+        if (!expressionValidation.isValid) {
+          throw new Error(`Invalid expression: ${expressionValidation.error}`);
+        }
+
+        const instance = await 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' as const,
+            text: JSON.stringify({
+              success: true,
+              expression,
+              command,
+              simplified: simplifiedValue
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to simplify expression', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string;
+        const min = params['min'] as number;
+        const max = params['max'] as number;
+        const increment = (params['increment'] as number) || 0.1;
+        const defaultValue = (params['defaultValue'] as number) || min;
+        const width = (params['width'] as number) || 150;
+        const isAngle = (params['isAngle'] as boolean) || false;
+        const horizontal = (params['horizontal'] as boolean) !== false;
+
+        // Validate parameters
+        const validation = validateSliderParameters(name, min, max, increment, defaultValue);
+        if (!validation.isValid) {
+          throw new Error(validation.error);
+        }
+
+        const instance = await 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' as const,
+            text: JSON.stringify({
+              success: true,
+              command,
+              slider: {
+                name,
+                min,
+                max,
+                increment,
+                currentValue: defaultValue,
+                width,
+                isAngle,
+                horizontal,
+                info: sliderInfo
+              }
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to create slider', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string;
+        const animate = params['animate'] as boolean;
+        const speed = (params['speed'] as number) || 1;
+        const direction = (params['direction'] as string) || 'forward';
+
+        // Validate parameters
+        const nameValidation = validateObjectName(objectName);
+        if (!nameValidation.isValid) {
+          throw new Error(`Invalid object name: ${nameValidation.error}`);
+        }
+
+        const speedValidation = validateAnimationSpeed(speed);
+        if (!speedValidation.isValid) {
+          throw new Error(speedValidation.error);
+        }
+
+        const directionValidation = validateAnimationDirection(direction);
+        if (!directionValidation.isValid) {
+          throw new Error(directionValidation.error);
+        }
+
+        const instance = await 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' as const,
+            text: JSON.stringify({
+              success: true,
+              animation: {
+                objectName,
+                animate,
+                speed: animate ? speed : null,
+                direction,
+                objectInfo
+              }
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to configure animation', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string;
+        const enableTrace = params['enableTrace'] as boolean;
+
+        // Validate object name
+        const nameValidation = validateObjectName(objectName);
+        if (!nameValidation.isValid) {
+          throw new Error(`Invalid object name: ${nameValidation.error}`);
+        }
+
+        const instance = await 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' as const,
+            text: JSON.stringify({
+              success: true,
+              trace: {
+                objectName,
+                enableTrace,
+                objectInfo
+              }
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to set trace', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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 instancePool.getDefaultInstance();
+
+        await instance.startAnimation();
+        const isRunning = await instance.isAnimationRunning();
+
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: true,
+              action: 'start_animation',
+              isRunning
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to start animation', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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 instancePool.getDefaultInstance();
+
+        await instance.stopAnimation();
+        const isRunning = await instance.isAnimationRunning();
+
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: true,
+              action: 'stop_animation',
+              isRunning
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to stop animation', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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 instancePool.getDefaultInstance();
+
+        const isRunning = await instance.isAnimationRunning();
+
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: true,
+              action: 'check_animation_status',
+              isRunning
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to check animation status', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as number) || 30;
+        const frameDelay = (params['frameDelay'] as number) || 100;
+        const totalDuration = (params['totalDuration'] as number) || ((frameCount * frameDelay) / 1000);
+        const width = params['width'] as number;
+        const height = params['height'] as number;
+        const scale = Math.min(Math.max((params['scale'] as number) || 1, 0.5), 3);
+        const format = (params['format'] as string) || 'png';
+
+        // Validate export parameters FIRST before any other operations
+        const validation = validateAnimationExportParameters(frameCount, frameDelay, totalDuration);
+        if (!validation.isValid) {
+          throw new Error(validation.error);
+        }
+
+        const instance = await 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' as const, // Always export as frames for now
+          width,
+          height
+        };
+
+        logger.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.info(`Animation export completed: ${frames.length} frames captured`);
+
+        return {
+          content: [{
+            type: 'text' as const,
+            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.error('Failed to export animation', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string) || 'parametric_spiral';
+        const animationSpeed = Math.min(Math.max((params['animationSpeed'] as number) || 1, 0.1), 5);
+
+        const instance = await instancePool.getDefaultInstance();
+
+        // Clear any existing construction
+        await instance.newConstruction();
+
+        let createdObjects: string[] = [];
+        let animatedObjects: string[] = [];
+
+        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' as const,
+            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.error('Failed to create animation demo', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string;
+        const point1 = params['point1'] as string;
+        const point2 = params['point2'] as string;
+        const color = params['color'] as string | undefined;
+        const thickness = params['thickness'] as number | undefined;
+        const style = params['style'] as string | undefined;
+        
+        // Validate segment name
+        const nameValidation = validateObjectName(name);
+        if (!nameValidation.isValid) {
+          throw new Error(`Invalid segment name: ${nameValidation.error}`);
+        }
+        
+        // Validate point names
+        const point1Validation = validateObjectName(point1);
+        if (!point1Validation.isValid) {
+          throw new Error(`Invalid first point name: ${point1Validation.error}`);
+        }
+        
+        const point2Validation = validateObjectName(point2);
+        if (!point2Validation.isValid) {
+          throw new Error(`Invalid second point name: ${point2Validation.error}`);
+        }
+        
+        const instance = await 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: string[] = [];
+        
+        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' as const,
+            text: JSON.stringify({
+              success: true,
+              command,
+              segment: segmentInfo,
+              styling: {
+                color,
+                thickness,
+                style
+              }
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to create line segment', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            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'] as string;
+        const x = params['x'] as number;
+        const y = params['y'] as number;
+        const fontSize = (params['fontSize'] as number) || 12;
+        const color = params['color'] as string | undefined;
+        const fontStyle = (params['fontStyle'] as string) || 'normal';
+        const name = (params['name'] as string) || `text_${Date.now()}`;
+        
+        // Validate text object name
+        const nameValidation = validateObjectName(name);
+        if (!nameValidation.isValid) {
+          throw new Error(`Invalid text name: ${nameValidation.error}`);
+        }
+        
+        // Validate coordinates
+        const coordValidation = validateCoordinates(x, y);
+        if (!coordValidation.isValid) {
+          throw new Error(`Invalid coordinates: ${coordValidation.error}`);
+        }
+        
+        const instance = await instancePool.getDefaultInstance();
+        
+        // Format the text content properly for GeoGebra
+        let formattedText: string;
+        
+        // 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: string[] = [];
+        
+        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' as const,
+            text: JSON.stringify({
+              success: true,
+              command,
+              textObject: textInfo,
+              position: { x, y },
+              styling: {
+                fontSize,
+                color,
+                fontStyle
+              }
+            }, null, 2)
+          }]
+        };
+      } catch (error) {
+        logger.error('Failed to create text', error);
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify({
+              success: false,
+              error: error instanceof Error ? error.message : String(error)
+            }, null, 2)
+          }],
+          isError: true
+        };
+      }
+    }
+  }
+];