@jgardner04/ghost-mcp-server 1.13.4 → 1.14.0

package/src/mcp_server.js

@@ -11,6 +11,7 @@ import crypto from 'crypto';
 import { ValidationError } from './errors/index.js';
 import { validateToolInput } from './utils/validation.js';
 import { trackTempFile, cleanupTempFiles } from './utils/tempFileManager.js';
+import { resolveLocalImagePath, decodeBase64ToTempFile } from './utils/imageInputResolver.js';
 import {
   createTagSchema,
   updateTagSchema,
@@ -83,6 +84,49 @@ const escapeNqlValue = (value) => {
   return value.replace(/'/g, "''");
 };
 
+/**
+ * Higher-order function that wraps a tool handler with standardized
+ * input validation, service loading, and error handling.
+ *
+ * Note: Each registerTool call passes the schema twice — once as `inputSchema`
+ * (MCP protocol metadata exposed to clients) and once here for runtime input
+ * validation via validateToolInput. These serve different purposes and both
+ * are required.
+ *
+ * @param {string} toolName - The tool identifier (e.g., 'ghost_get_tags')
+ * @param {object} schema - Zod schema for input validation
+ * @param {Function} handler - Async function receiving validated input, returns MCP response
+ * @returns {Function} Wrapped async handler for server.registerTool
+ */
+const withErrorHandling = (toolName, schema, handler) => {
+  const zodContext = toolName.replace('ghost_', '').replace(/_/g, ' ');
+  return async (rawInput) => {
+    console.error(`Executing tool: ${toolName}`);
+    const validation = validateToolInput(schema, rawInput, toolName);
+    if (!validation.success) {
+      return validation.errorResponse;
+    }
+
+    try {
+      await loadServices();
+      return await handler(validation.data);
+    } catch (error) {
+      console.error(`Error in ${toolName}:`, error);
+      if (error.name === 'ZodError') {
+        const validationError = ValidationError.fromZod(error, zodContext);
+        return {
+          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
+          isError: true,
+        };
+      }
+      return {
+        content: [{ type: 'text', text: `Error in ${toolName}: ${error.message}` }],
+        isError: true,
+      };
+    }
+  };
+};
+
 // Create server instance with new API
 const server = new McpServer({
   name: 'ghost-mcp-server',
@@ -116,58 +160,32 @@ server.registerTool(
       'Retrieves a list of tags from Ghost CMS with pagination, filtering, sorting, and relation inclusion. Supports filtering by name, slug, visibility, or custom NQL filter expressions.',
     inputSchema: getTagsSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(getTagsSchema, rawInput, 'ghost_get_tags');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_get_tags`);
-    try {
-      await loadServices();
-
-      // Build options object with provided parameters
-      const options = {};
-      if (input.limit !== undefined) options.limit = input.limit;
-      if (input.page !== undefined) options.page = input.page;
-      if (input.order !== undefined) options.order = input.order;
-      if (input.include !== undefined) options.include = input.include;
-
-      // Build filter string from individual filter parameters
-      const filters = [];
-      if (input.name) filters.push(`name:'${escapeNqlValue(input.name)}'`);
-      if (input.slug) filters.push(`slug:'${escapeNqlValue(input.slug)}'`);
-      if (input.visibility) filters.push(`visibility:'${input.visibility}'`); // visibility is enum-validated, no escaping needed
-      if (input.filter) filters.push(input.filter);
-
-      if (filters.length > 0) {
-        options.filter = filters.join('+');
-      }
-
-      const tags = await ghostService.getTags(options);
-      console.error(`Retrieved ${tags.length} tags from Ghost.`);
-
-      const result = tags;
-
-      return {
-        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_get_tags:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Tags retrieval');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+  withErrorHandling('ghost_get_tags', getTagsSchema, async (input) => {
+    // Build options object with provided parameters
+    const options = {};
+    if (input.limit !== undefined) options.limit = input.limit;
+    if (input.page !== undefined) options.page = input.page;
+    if (input.order !== undefined) options.order = input.order;
+    if (input.include !== undefined) options.include = input.include;
+
+    // Build filter string from individual filter parameters
+    const filters = [];
+    if (input.name) filters.push(`name:'${escapeNqlValue(input.name)}'`);
+    if (input.slug) filters.push(`slug:'${escapeNqlValue(input.slug)}'`);
+    if (input.visibility) filters.push(`visibility:'${input.visibility}'`); // visibility is enum-validated, no escaping needed
+    if (input.filter) filters.push(input.filter);
+
+    if (filters.length > 0) {
+      options.filter = filters.join('+');
+    }
+
+    const tags = await ghostService.getTags(options);
+    console.error(`Retrieved ${tags.length} tags from Ghost.`);
+
+    return {
+      content: [{ type: 'text', text: JSON.stringify(tags, null, 2) }],
+    };
+  })
 );
 
 // Create Tag Tool
@@ -177,37 +195,14 @@ server.registerTool(
     description: 'Creates a new tag in Ghost CMS.',
     inputSchema: createTagSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(createTagSchema, rawInput, 'ghost_create_tag');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
+  withErrorHandling('ghost_create_tag', createTagSchema, async (input) => {
+    const createdTag = await ghostService.createTag(input);
+    console.error(`Tag created successfully. Tag ID: ${createdTag.id}`);
 
-    console.error(`Executing tool: ghost_create_tag with name: ${input.name}`);
-    try {
-      await loadServices();
-      const createdTag = await ghostService.createTag(input);
-      console.error(`Tag created successfully. Tag ID: ${createdTag.id}`);
-
-      return {
-        content: [{ type: 'text', text: JSON.stringify(createdTag, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_create_tag:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Tag creation');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+    return {
+      content: [{ type: 'text', text: JSON.stringify(createdTag, null, 2) }],
+    };
+  })
 );
 
 // Get Tag Tool
@@ -217,42 +212,22 @@ server.registerTool(
     description: 'Retrieves a single tag from Ghost CMS by ID or slug.',
     inputSchema: getTagSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(getTagSchema, rawInput, 'ghost_get_tag');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const { id, slug, include } = validation.data;
-
-    console.error(`Executing tool: ghost_get_tag`);
-    try {
-      await loadServices();
+  withErrorHandling('ghost_get_tag', getTagSchema, async (input) => {
+    const options = {};
+    if (input.include !== undefined) options.include = input.include;
 
-      // If slug is provided, use the slug/slug-name format
-      const identifier = slug ? `slug/${slug}` : id;
-      const options = include ? { include } : {};
+    if (!input.id && !input.slug) {
+      throw new Error('Either id or slug is required');
+    }
+    const identifier = input.id || `slug/${input.slug}`;
 
-      const tag = await ghostService.getTag(identifier, options);
-      console.error(`Tag retrieved successfully. Tag ID: ${tag.id}`);
+    const tag = await ghostService.getTag(identifier, options);
+    console.error(`Retrieved tag: ${tag.name} (ID: ${tag.id})`);
 
-      return {
-        content: [{ type: 'text', text: JSON.stringify(tag, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_get_tag:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Tag retrieval');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+    return {
+      content: [{ type: 'text', text: JSON.stringify(tag, null, 2) }],
+    };
+  })
 );
 
 // Update Tag Tool
@@ -262,184 +237,321 @@ server.registerTool(
     description: 'Updates an existing tag in Ghost CMS.',
     inputSchema: updateTagInputSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(updateTagInputSchema, rawInput, 'ghost_update_tag');
-    if (!validation.success) {
-      return validation.errorResponse;
+  withErrorHandling('ghost_update_tag', updateTagInputSchema, async (input) => {
+    const { id, ...updateData } = input;
+    const updatedTag = await ghostService.updateTag(id, updateData);
+    console.error(`Tag updated successfully. Tag ID: ${updatedTag.id}`);
+
+    return {
+      content: [{ type: 'text', text: JSON.stringify(updatedTag, null, 2) }],
+    };
+  })
+);
+
+// Delete Tag Tool
+server.registerTool(
+  'ghost_delete_tag',
+  {
+    description:
+      'Deletes a tag from Ghost CMS by ID. This operation is permanent and cannot be undone.',
+    inputSchema: deleteTagSchema,
+  },
+  withErrorHandling('ghost_delete_tag', deleteTagSchema, async (input) => {
+    const { id } = input;
+    await ghostService.deleteTag(id);
+    console.error(`Tag deleted successfully. Tag ID: ${id}`);
+
+    return {
+      content: [{ type: 'text', text: `Tag ${id} has been successfully deleted.` }],
+    };
+  })
+);
+
+// --- Image Schema ---
+// Base object (plain ZodObject — keeps `.shape` available for MCP schema
+// introspection). Runtime XOR validation is applied at the tool level
+// via a manual check so we never wrap with ZodEffects.
+const imageInputFields = {
+  imageUrl: z.string().optional().meta({
+    description: 'The publicly accessible URL of the image to download and upload.',
+  }),
+  imagePath: z.string().optional().meta({
+    description:
+      'Absolute path to a local image file. Only accepted when the GHOST_MCP_IMAGE_ROOT env var is set; paths must resolve inside that root.',
+  }),
+  imageBase64: z.string().optional().meta({
+    description:
+      'Base64-encoded image bytes (with or without data: URI prefix). Decoded size capped at 5MB to respect MCP transport limits. Requires mimeType.',
+  }),
+  mimeType: z.string().optional().meta({
+    description:
+      'MIME type for imageBase64 input (e.g. image/png, image/jpeg, image/svg+xml). Required when imageBase64 is used.',
+  }),
+  alt: z.string().optional().meta({
+    description:
+      'Alt text for the image. If omitted, a default will be generated from the filename.',
+  }),
+  purpose: z.enum(['image', 'profile_image', 'icon']).optional().meta({
+    description:
+      'Intended use. Ghost validates format/size per purpose (icon/profile_image must be square; icon also accepts ICO).',
+  }),
+  ref: z.string().max(200).optional().meta({
+    description:
+      'Caller-supplied identifier (e.g. original filename). Ghost echoes it back in the response.',
+  }),
+};
+
+const uploadImageSchema = z.object(imageInputFields);
+
+function validateImageInputXor(data) {
+  const count = Number(!!data.imageUrl) + Number(!!data.imagePath) + Number(!!data.imageBase64);
+  if (count !== 1) return 'Provide exactly one of imageUrl, imagePath, or imageBase64.';
+  if (data.imageBase64 && !data.mimeType) {
+    return 'mimeType is required when imageBase64 is provided.';
+  }
+  return null;
+}
+
+// Axios does not enforce `maxContentLength` for responseType: 'stream',
+// so we cap downloads here by watching bytes on the response stream and
+// destroying it on overflow. Mirrors the config value in urlValidator.js.
+const DOWNLOAD_CAP_BYTES = 50 * 1024 * 1024;
+
+async function acquireImageForUpload({ imageUrl, imagePath: localPath, imageBase64, mimeType }) {
+  const tempDir = os.tmpdir();
+
+  if (imageUrl) {
+    const urlValidation = urlValidator.validateImageUrl(imageUrl);
+    if (!urlValidation.isValid) {
+      throw new Error(`Invalid image URL: ${urlValidation.error}`);
     }
-    const input = validation.data;
+    const axiosConfig = urlValidator.createSecureAxiosConfig(urlValidation.sanitizedUrl);
+    const response = await axios(axiosConfig);
 
-    console.error(`Executing tool: ghost_update_tag for ID: ${input.id}`);
-    try {
-      if (!input.id) {
-        throw new Error('Tag ID is required');
+    const declared = Number(response.headers['content-length']);
+    if (Number.isFinite(declared) && declared > DOWNLOAD_CAP_BYTES) {
+      response.data.destroy();
+      throw new Error(
+        `Image exceeds ${DOWNLOAD_CAP_BYTES} byte limit (server declared ${declared})`
+      );
+    }
+
+    const extension = path.extname(imageUrl.split('?')[0]) || '.tmp';
+    const filenameHint =
+      path.basename(imageUrl.split('?')[0]) || `image-${generateUuid()}${extension}`;
+    const downloadedPath = path.join(tempDir, `mcp-download-${generateUuid()}${extension}`);
+
+    let bytes = 0;
+    response.data.on('data', (chunk) => {
+      bytes += chunk.length;
+      if (bytes > DOWNLOAD_CAP_BYTES) {
+        response.data.destroy(new Error(`Image exceeds ${DOWNLOAD_CAP_BYTES} byte limit`));
       }
+    });
+
+    const writer = fs.createWriteStream(downloadedPath);
+    response.data.pipe(writer);
+    await new Promise((resolve, reject) => {
+      writer.on('finish', resolve);
+      writer.on('error', reject);
+      response.data.on('error', reject);
+    });
+    return { acquiredPath: downloadedPath, filenameHint, source: 'url' };
+  }
 
-      await loadServices();
+  if (localPath) {
+    const resolved = await resolveLocalImagePath(localPath);
+    return { acquiredPath: resolved, filenameHint: path.basename(resolved), source: 'path' };
+  }
 
-      // Build update data object with only provided fields (exclude id from update data)
-      const { id, ...updateData } = input;
+  if (imageBase64) {
+    const decodedPath = await decodeBase64ToTempFile(imageBase64, mimeType);
+    return {
+      acquiredPath: decodedPath,
+      filenameHint: path.basename(decodedPath),
+      source: 'base64',
+    };
+  }
 
-      const updatedTag = await ghostService.updateTag(id, updateData);
-      console.error(`Tag updated successfully. Tag ID: ${updatedTag.id}`);
+  throw new Error('No image input provided'); // unreachable — schema enforces one
+}
 
-      return {
-        content: [{ type: 'text', text: JSON.stringify(updatedTag, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_update_tag:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Tag update');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error: ${error.message}` }],
-        isError: true,
-      };
-    }
+/**
+ * Acquire → process → upload an image from a validated input. Owns its
+ * own temp-file lifecycle. Returns { uploadResult, filenameHint, finalAltText }.
+ * Does NOT delete the caller's imagePath file.
+ */
+async function performImageUpload(data) {
+  await loadServices();
+
+  let acquiredPath = null;
+  let processedPath = null;
+
+  try {
+    const acquired = await acquireImageForUpload(data);
+    acquiredPath = acquired.acquiredPath;
+    if (acquired.source !== 'path') trackTempFile(acquiredPath);
+
+    processedPath = await imageProcessingService.processImage(
+      acquiredPath,
+      os.tmpdir(),
+      data.purpose ? { purpose: data.purpose } : {}
+    );
+    if (processedPath !== acquiredPath) trackTempFile(processedPath);
+
+    const uploadOpts = {};
+    if (data.purpose) uploadOpts.purpose = data.purpose;
+    if (data.ref) uploadOpts.ref = data.ref;
+    else if (acquired.filenameHint) uploadOpts.ref = acquired.filenameHint.slice(0, 200);
+
+    const uploadResult = await ghostService.uploadImage(processedPath, uploadOpts);
+    const finalAltText = data.alt || getDefaultAltText(acquired.filenameHint);
+
+    return { uploadResult, filenameHint: acquired.filenameHint, finalAltText };
+  } finally {
+    const toClean = [];
+    if (acquiredPath && !data.imagePath) toClean.push(acquiredPath);
+    if (processedPath && processedPath !== acquiredPath) toClean.push(processedPath);
+    if (toClean.length > 0) await cleanupTempFiles(toClean, console);
   }
-);
+}
 
-// Delete Tag Tool
+/**
+ * Runs the standard tool-input validation then the XOR image-input check.
+ * Returns { success: true, data } or { success: false, errorResponse }
+ * so both image tools can collapse their validation prelude to one call.
+ */
+function validateAndXorImageInput(schema, rawInput, toolName) {
+  const validation = validateToolInput(schema, rawInput, toolName);
+  if (!validation.success) return validation;
+  const xorError = validateImageInputXor(validation.data);
+  if (xorError) {
+    return {
+      success: false,
+      errorResponse: { content: [{ type: 'text', text: xorError }], isError: true },
+    };
+  }
+  return validation;
+}
+
+// Upload Image Tool
 server.registerTool(
-  'ghost_delete_tag',
+  'ghost_upload_image',
   {
-    description: 'Deletes a tag from Ghost CMS by ID. This operation is permanent.',
-    inputSchema: deleteTagSchema,
+    description:
+      'Uploads an image to Ghost CMS. Accepts a remote URL, a local file path (when GHOST_MCP_IMAGE_ROOT is configured), or a base64 payload. Returns the Ghost image URL, alt text, and ref (when Ghost echoes it).',
+    inputSchema: uploadImageSchema,
   },
   async (rawInput) => {
-    const validation = validateToolInput(deleteTagSchema, rawInput, 'ghost_delete_tag');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const { id } = validation.data;
+    const validation = validateAndXorImageInput(uploadImageSchema, rawInput, 'ghost_upload_image');
+    if (!validation.success) return validation.errorResponse;
 
-    console.error(`Executing tool: ghost_delete_tag for ID: ${id}`);
     try {
-      if (!id) {
-        throw new Error('Tag ID is required');
-      }
-
-      await loadServices();
-
-      await ghostService.deleteTag(id);
-      console.error(`Tag deleted successfully. Tag ID: ${id}`);
-
-      return {
-        content: [{ type: 'text', text: `Tag with ID ${id} has been successfully deleted.` }],
-      };
+      const { uploadResult, finalAltText } = await performImageUpload(validation.data);
+      const result = { url: uploadResult.url, alt: finalAltText };
+      if (uploadResult.ref) result.ref = uploadResult.ref;
+      return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
     } catch (error) {
-      console.error(`Error in ghost_delete_tag:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Tag deletion');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
+      console.error(`Error in ghost_upload_image:`, error);
       return {
-        content: [{ type: 'text', text: `Error: ${error.message}` }],
+        content: [{ type: 'text', text: `Error uploading image: ${error.message}` }],
         isError: true,
       };
     }
   }
 );
 
-// --- Image Schema ---
-const uploadImageSchema = z.object({
-  imageUrl: z.string().meta({ description: 'The publicly accessible URL of the image to upload.' }),
-  alt: z.string().optional().meta({
-    description:
-      'Alt text for the image. If omitted, a default will be generated from the filename.',
+// --- Set Feature Image Tool ---
+// Combined upload-and-assign flow. Ghost has no delete-image endpoint,
+// so when the post/page update fails after a successful upload, the
+// image is orphaned in Ghost's storage — we surface its URL in the
+// error response so the caller can reuse or record it.
+const setFeatureImageSchema = uploadImageSchema.extend({
+  type: z.enum(['post', 'page']).meta({
+    description: 'Which resource to attach the feature image to.',
+  }),
+  id: ghostIdSchema.meta({ description: 'ID of the post or page.' }),
+  caption: z.string().max(5000).optional().meta({
+    description: 'Optional HTML caption for the feature image (max 5000 chars).',
   }),
 });
 
-// Upload Image Tool
 server.registerTool(
-  'ghost_upload_image',
+  'ghost_set_feature_image',
   {
     description:
-      'Downloads an image from a URL, processes it, uploads it to Ghost CMS, and returns the final Ghost image URL and alt text.',
-    inputSchema: uploadImageSchema,
+      'Uploads an image and assigns it as the feature image of a post or page (with optional alt text and caption) in one call. Accepts the same imageUrl/imagePath/imageBase64 input modes as ghost_upload_image. Returns the updated resource. If the update fails after the upload, the error response includes the orphaned image URL.',
+    inputSchema: setFeatureImageSchema,
   },
   async (rawInput) => {
-    const validation = validateToolInput(uploadImageSchema, rawInput, 'ghost_upload_image');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const { imageUrl, alt } = validation.data;
+    const validation = validateAndXorImageInput(
+      setFeatureImageSchema,
+      rawInput,
+      'ghost_set_feature_image'
+    );
+    if (!validation.success) return validation.errorResponse;
 
-    console.error(`Executing tool: ghost_upload_image for URL: ${imageUrl}`);
-    let downloadedPath = null;
-    let processedPath = null;
+    const { type, id, caption } = validation.data;
 
+    let uploadedUrl;
+    let uploadedRef;
+    let altText;
     try {
-      await loadServices();
-
-      // 1. Validate URL for SSRF protection
-      const urlValidation = urlValidator.validateImageUrl(imageUrl);
-      if (!urlValidation.isValid) {
-        throw new Error(`Invalid image URL: ${urlValidation.error}`);
-      }
-
-      // 2. Download the image with security controls
-      const axiosConfig = urlValidator.createSecureAxiosConfig(urlValidation.sanitizedUrl);
-      const response = await axios(axiosConfig);
-      const tempDir = os.tmpdir();
-      const extension = path.extname(imageUrl.split('?')[0]) || '.tmp';
-      const originalFilenameHint =
-        path.basename(imageUrl.split('?')[0]) || `image-${generateUuid()}${extension}`;
-      downloadedPath = path.join(tempDir, `mcp-download-${generateUuid()}${extension}`);
-
-      const writer = fs.createWriteStream(downloadedPath);
-      response.data.pipe(writer);
-
-      await new Promise((resolve, reject) => {
-        writer.on('finish', resolve);
-        writer.on('error', reject);
-      });
-      // Track temp file for cleanup on process exit
-      trackTempFile(downloadedPath);
-      console.error(`Downloaded image to temporary path: ${downloadedPath}`);
-
-      // 3. Process the image
-      processedPath = await imageProcessingService.processImage(downloadedPath, tempDir);
-      // Track processed file for cleanup on process exit
-      if (processedPath !== downloadedPath) {
-        trackTempFile(processedPath);
-      }
-      console.error(`Processed image path: ${processedPath}`);
-
-      // 4. Determine Alt Text
-      const defaultAlt = getDefaultAltText(originalFilenameHint);
-      const finalAltText = alt || defaultAlt;
-      console.error(`Using alt text: "${finalAltText}"`);
-
-      // 5. Upload processed image to Ghost
-      const uploadResult = await ghostService.uploadImage(processedPath);
-      console.error(`Uploaded processed image to Ghost: ${uploadResult.url}`);
-
-      // 6. Return result
-      const result = {
-        url: uploadResult.url,
-        alt: finalAltText,
+      const { uploadResult, finalAltText } = await performImageUpload(validation.data);
+      uploadedUrl = uploadResult.url;
+      uploadedRef = uploadResult.ref;
+      altText = finalAltText;
+    } catch (error) {
+      console.error(`ghost_set_feature_image: upload failed`, error);
+      return {
+        content: [{ type: 'text', text: `Upload failed: ${error.message}` }],
+        isError: true,
       };
+    }
 
-      return {
-        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    const updatePayload = {
+      feature_image: uploadedUrl,
+      feature_image_alt: altText,
+    };
+    if (caption !== undefined) updatePayload.feature_image_caption = caption;
+
+    try {
+      const updated =
+        type === 'post'
+          ? await ghostService.updatePost(id, updatePayload)
+          : await ghostService.updatePage(id, updatePayload);
+      console.error(`ghost_set_feature_image: ${type} ${id} updated with ${uploadedUrl}`);
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(
+              { uploaded: { url: uploadedUrl, ref: uploadedRef, alt: altText }, [type]: updated },
+              null,
+              2
+            ),
+          },
+        ],
       };
     } catch (error) {
-      console.error(`Error in ghost_upload_image:`, error);
-      return {
-        content: [{ type: 'text', text: `Error uploading image: ${error.message}` }],
+      console.error(`ghost_set_feature_image: update failed (orphaned ${uploadedUrl})`, error);
+      return {
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(
+              {
+                error: `Upload succeeded but ${type} update failed: ${error.message}`,
+                orphanedImage: { url: uploadedUrl, ref: uploadedRef, alt: altText },
+                hint: 'Ghost does not expose a delete-image endpoint; reuse this URL or leave it orphaned.',
+              },
+              null,
+              2
+            ),
+          },
+        ],
         isError: true,
       };
-    } finally {
-      // Cleanup temporary files with proper async/await
-      await cleanupTempFiles([downloadedPath, processedPath], console);
     }
   }
 );
@@ -486,37 +598,14 @@ server.registerTool(
     description: 'Creates a new post in Ghost CMS.',
     inputSchema: createPostSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(createPostSchema, rawInput, 'ghost_create_post');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
+  withErrorHandling('ghost_create_post', createPostSchema, async (input) => {
+    const createdPost = await postService.createPostService(input);
+    console.error(`Post created successfully. Post ID: ${createdPost.id}`);
 
-    console.error(`Executing tool: ghost_create_post with title: ${input.title}`);
-    try {
-      await loadServices();
-      const createdPost = await postService.createPostService(input);
-      console.error(`Post created successfully. Post ID: ${createdPost.id}`);
-
-      return {
-        content: [{ type: 'text', text: JSON.stringify(createdPost, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_create_post:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Post creation');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error creating post: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+    return {
+      content: [{ type: 'text', text: JSON.stringify(createdPost, null, 2) }],
+    };
+  })
 );
 
 // Get Posts Tool
@@ -527,50 +616,26 @@ server.registerTool(
       'Retrieves a list of posts from Ghost CMS with pagination, filtering, and sorting options.',
     inputSchema: getPostsSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(getPostsSchema, rawInput, 'ghost_get_posts');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_get_posts`);
-    try {
-      await loadServices();
-
-      // Build options object with provided parameters
-      const options = {};
-      if (input.limit !== undefined) options.limit = input.limit;
-      if (input.page !== undefined) options.page = input.page;
-      if (input.status !== undefined) options.status = input.status;
-      if (input.include !== undefined) options.include = input.include;
-      if (input.filter !== undefined) options.filter = input.filter;
-      if (input.order !== undefined) options.order = input.order;
-      if (input.fields !== undefined) options.fields = input.fields;
-      if (input.formats !== undefined) options.formats = input.formats;
-
-      const posts = await ghostService.getPosts(options);
-      console.error(`Retrieved ${posts.length} posts from Ghost.`);
-
-      return {
-        content: [{ type: 'text', text: JSON.stringify(posts, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_get_posts:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Posts retrieval');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error retrieving posts: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
-);
+  withErrorHandling('ghost_get_posts', getPostsSchema, async (input) => {
+    // Build options object with provided parameters
+    const options = {};
+    if (input.limit !== undefined) options.limit = input.limit;
+    if (input.page !== undefined) options.page = input.page;
+    if (input.status !== undefined) options.status = input.status;
+    if (input.include !== undefined) options.include = input.include;
+    if (input.filter !== undefined) options.filter = input.filter;
+    if (input.order !== undefined) options.order = input.order;
+    if (input.fields !== undefined) options.fields = input.fields;
+    if (input.formats !== undefined) options.formats = input.formats;
+
+    const posts = await ghostService.getPosts(options);
+    console.error(`Retrieved ${posts.length} posts from Ghost.`);
+
+    return {
+      content: [{ type: 'text', text: JSON.stringify(posts, null, 2) }],
+    };
+  })
+);
 
 // Get Post Tool
 server.registerTool(
@@ -579,45 +644,24 @@ server.registerTool(
     description: 'Retrieves a single post from Ghost CMS by ID or slug.',
     inputSchema: getPostSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(getPostSchema, rawInput, 'ghost_get_post');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_get_post`);
-    try {
-      await loadServices();
+  withErrorHandling('ghost_get_post', getPostSchema, async (input) => {
+    // Build options object
+    const options = {};
+    if (input.include !== undefined) options.include = input.include;
 
-      // Build options object
-      const options = {};
-      if (input.include !== undefined) options.include = input.include;
-
-      // Determine identifier (prefer ID over slug)
-      const identifier = input.id || `slug/${input.slug}`;
+    // Determine identifier (prefer ID over slug)
+    if (!input.id && !input.slug) {
+      throw new Error('Either id or slug is required');
+    }
+    const identifier = input.id || `slug/${input.slug}`;
 
-      const post = await ghostService.getPost(identifier, options);
-      console.error(`Retrieved post: ${post.title} (ID: ${post.id})`);
+    const post = await ghostService.getPost(identifier, options);
+    console.error(`Retrieved post: ${post.title} (ID: ${post.id})`);
 
-      return {
-        content: [{ type: 'text', text: JSON.stringify(post, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_get_post:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Post retrieval');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error retrieving post: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+    return {
+      content: [{ type: 'text', text: JSON.stringify(post, null, 2) }],
+    };
+  })
 );
 
 // Search Posts Tool
@@ -627,43 +671,19 @@ server.registerTool(
     description: 'Search for posts in Ghost CMS by query string with optional status filtering.',
     inputSchema: searchPostsSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(searchPostsSchema, rawInput, 'ghost_search_posts');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_search_posts with query: ${input.query}`);
-    try {
-      await loadServices();
-
-      // Build options object with provided parameters
-      const options = {};
-      if (input.status !== undefined) options.status = input.status;
-      if (input.limit !== undefined) options.limit = input.limit;
-
-      const posts = await ghostService.searchPosts(input.query, options);
-      console.error(`Found ${posts.length} posts matching "${input.query}".`);
-
-      return {
-        content: [{ type: 'text', text: JSON.stringify(posts, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_search_posts:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Post search');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error searching posts: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+  withErrorHandling('ghost_search_posts', searchPostsSchema, async (input) => {
+    // Build options object with provided parameters
+    const options = {};
+    if (input.status !== undefined) options.status = input.status;
+    if (input.limit !== undefined) options.limit = input.limit;
+
+    const posts = await ghostService.searchPosts(input.query, options);
+    console.error(`Found ${posts.length} posts matching "${input.query}".`);
+
+    return {
+      content: [{ type: 'text', text: JSON.stringify(posts, null, 2) }],
+    };
+  })
 );
 
 // Update Post Tool
@@ -674,41 +694,17 @@ server.registerTool(
       'Updates an existing post in Ghost CMS. Can update title, content, status, tags, images, and SEO fields. Only the provided fields are changed; omitted fields remain unchanged. Note: tags and authors arrays are fully replaced, not merged with existing values.',
     inputSchema: updatePostInputSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(updatePostInputSchema, rawInput, 'ghost_update_post');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_update_post for post ID: ${input.id}`);
-    try {
-      await loadServices();
-
-      // Extract ID from input and build update data
-      const { id, ...updateData } = input;
+  withErrorHandling('ghost_update_post', updatePostInputSchema, async (input) => {
+    // Extract ID from input and build update data
+    const { id, ...updateData } = input;
 
-      const updatedPost = await ghostService.updatePost(id, updateData);
-      console.error(`Post updated successfully. Post ID: ${updatedPost.id}`);
+    const updatedPost = await ghostService.updatePost(id, updateData);
+    console.error(`Post updated successfully. Post ID: ${updatedPost.id}`);
 
-      return {
-        content: [{ type: 'text', text: JSON.stringify(updatedPost, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_update_post:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Post update');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error updating post: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+    return {
+      content: [{ type: 'text', text: JSON.stringify(updatedPost, null, 2) }],
+    };
+  })
 );
 
 // Delete Post Tool
@@ -719,38 +715,15 @@ server.registerTool(
       'Deletes a post from Ghost CMS by ID. This operation is permanent and cannot be undone.',
     inputSchema: deletePostSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(deletePostSchema, rawInput, 'ghost_delete_post');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const { id } = validation.data;
-
-    console.error(`Executing tool: ghost_delete_post for post ID: ${id}`);
-    try {
-      await loadServices();
-
-      await ghostService.deletePost(id);
-      console.error(`Post deleted successfully. Post ID: ${id}`);
-
-      return {
-        content: [{ type: 'text', text: `Post ${id} has been successfully deleted.` }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_delete_post:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Post deletion');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error deleting post: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+  withErrorHandling('ghost_delete_post', deletePostSchema, async (input) => {
+    const { id } = input;
+    await ghostService.deletePost(id);
+    console.error(`Post deleted successfully. Post ID: ${id}`);
+
+    return {
+      content: [{ type: 'text', text: `Post ${id} has been successfully deleted.` }],
+    };
+  })
 );
 
 // =============================================================================
@@ -804,47 +777,23 @@ server.registerTool(
       'Retrieves a list of pages from Ghost CMS with pagination, filtering, and sorting options.',
     inputSchema: pageQuerySchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(pageQuerySchema, rawInput, 'ghost_get_pages');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_get_pages`);
-    try {
-      await loadServices();
-
-      const options = {};
-      if (input.limit !== undefined) options.limit = input.limit;
-      if (input.page !== undefined) options.page = input.page;
-      if (input.filter !== undefined) options.filter = input.filter;
-      if (input.include !== undefined) options.include = input.include;
-      if (input.fields !== undefined) options.fields = input.fields;
-      if (input.formats !== undefined) options.formats = input.formats;
-      if (input.order !== undefined) options.order = input.order;
-
-      const pages = await ghostService.getPages(options);
-      console.error(`Retrieved ${pages.length} pages from Ghost.`);
-
-      return {
-        content: [{ type: 'text', text: JSON.stringify(pages, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_get_pages:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Page query');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error retrieving pages: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+  withErrorHandling('ghost_get_pages', pageQuerySchema, async (input) => {
+    const options = {};
+    if (input.limit !== undefined) options.limit = input.limit;
+    if (input.page !== undefined) options.page = input.page;
+    if (input.filter !== undefined) options.filter = input.filter;
+    if (input.include !== undefined) options.include = input.include;
+    if (input.fields !== undefined) options.fields = input.fields;
+    if (input.formats !== undefined) options.formats = input.formats;
+    if (input.order !== undefined) options.order = input.order;
+
+    const pages = await ghostService.getPages(options);
+    console.error(`Retrieved ${pages.length} pages from Ghost.`);
+
+    return {
+      content: [{ type: 'text', text: JSON.stringify(pages, null, 2) }],
+    };
+  })
 );
 
 // Get Page Tool
@@ -854,43 +803,22 @@ server.registerTool(
     description: 'Retrieves a single page from Ghost CMS by ID or slug.',
     inputSchema: getPageSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(getPageSchema, rawInput, 'ghost_get_page');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_get_page`);
-    try {
-      await loadServices();
-
-      const options = {};
-      if (input.include !== undefined) options.include = input.include;
+  withErrorHandling('ghost_get_page', getPageSchema, async (input) => {
+    const options = {};
+    if (input.include !== undefined) options.include = input.include;
 
-      const identifier = input.id || `slug/${input.slug}`;
+    if (!input.id && !input.slug) {
+      throw new Error('Either id or slug is required');
+    }
+    const identifier = input.id || `slug/${input.slug}`;
 
-      const page = await ghostService.getPage(identifier, options);
-      console.error(`Retrieved page: ${page.title} (ID: ${page.id})`);
+    const page = await ghostService.getPage(identifier, options);
+    console.error(`Retrieved page: ${page.title} (ID: ${page.id})`);
 
-      return {
-        content: [{ type: 'text', text: JSON.stringify(page, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_get_page:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Get page');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error retrieving page: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+    return {
+      content: [{ type: 'text', text: JSON.stringify(page, null, 2) }],
+    };
+  })
 );
 
 // Create Page Tool
@@ -901,38 +829,14 @@ server.registerTool(
       'Creates a new page in Ghost CMS. Note: Pages do NOT typically use tags (unlike posts).',
     inputSchema: createPageSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(createPageSchema, rawInput, 'ghost_create_page');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_create_page with title: ${input.title}`);
-    try {
-      await loadServices();
-
-      const createdPage = await pageService.createPageService(input);
-      console.error(`Page created successfully. Page ID: ${createdPage.id}`);
+  withErrorHandling('ghost_create_page', createPageSchema, async (input) => {
+    const createdPage = await pageService.createPageService(input);
+    console.error(`Page created successfully. Page ID: ${createdPage.id}`);
 
-      return {
-        content: [{ type: 'text', text: JSON.stringify(createdPage, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_create_page:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Page creation');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error creating page: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+    return {
+      content: [{ type: 'text', text: JSON.stringify(createdPage, null, 2) }],
+    };
+  })
 );
 
 // Update Page Tool
@@ -943,40 +847,16 @@ server.registerTool(
       'Updates an existing page in Ghost CMS. Can update title, content, status, images, and SEO fields. Only the provided fields are changed; omitted fields remain unchanged.',
     inputSchema: updatePageInputSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(updatePageInputSchema, rawInput, 'ghost_update_page');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_update_page for page ID: ${input.id}`);
-    try {
-      await loadServices();
+  withErrorHandling('ghost_update_page', updatePageInputSchema, async (input) => {
+    const { id, ...updateData } = input;
 
-      const { id, ...updateData } = input;
+    const updatedPage = await ghostService.updatePage(id, updateData);
+    console.error(`Page updated successfully. Page ID: ${updatedPage.id}`);
 
-      const updatedPage = await ghostService.updatePage(id, updateData);
-      console.error(`Page updated successfully. Page ID: ${updatedPage.id}`);
-
-      return {
-        content: [{ type: 'text', text: JSON.stringify(updatedPage, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_update_page:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Page update');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error updating page: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+    return {
+      content: [{ type: 'text', text: JSON.stringify(updatedPage, null, 2) }],
+    };
+  })
 );
 
 // Delete Page Tool
@@ -987,38 +867,15 @@ server.registerTool(
       'Deletes a page from Ghost CMS by ID. This operation is permanent and cannot be undone.',
     inputSchema: deletePageSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(deletePageSchema, rawInput, 'ghost_delete_page');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const { id } = validation.data;
-
-    console.error(`Executing tool: ghost_delete_page for page ID: ${id}`);
-    try {
-      await loadServices();
-
-      await ghostService.deletePage(id);
-      console.error(`Page deleted successfully. Page ID: ${id}`);
-
-      return {
-        content: [{ type: 'text', text: `Page ${id} has been successfully deleted.` }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_delete_page:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Page deletion');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error deleting page: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+  withErrorHandling('ghost_delete_page', deletePageSchema, async (input) => {
+    const { id } = input;
+    await ghostService.deletePage(id);
+    console.error(`Page deleted successfully. Page ID: ${id}`);
+
+    return {
+      content: [{ type: 'text', text: `Page ${id} has been successfully deleted.` }],
+    };
+  })
 );
 
 // Search Pages Tool
@@ -1028,42 +885,18 @@ server.registerTool(
     description: 'Search for pages in Ghost CMS by query string with optional status filtering.',
     inputSchema: searchPagesSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(searchPagesSchema, rawInput, 'ghost_search_pages');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_search_pages with query: ${input.query}`);
-    try {
-      await loadServices();
-
-      const options = {};
-      if (input.status !== undefined) options.status = input.status;
-      if (input.limit !== undefined) options.limit = input.limit;
+  withErrorHandling('ghost_search_pages', searchPagesSchema, async (input) => {
+    const options = {};
+    if (input.status !== undefined) options.status = input.status;
+    if (input.limit !== undefined) options.limit = input.limit;
 
-      const pages = await ghostService.searchPages(input.query, options);
-      console.error(`Found ${pages.length} pages matching "${input.query}".`);
+    const pages = await ghostService.searchPages(input.query, options);
+    console.error(`Found ${pages.length} pages matching "${input.query}".`);
 
-      return {
-        content: [{ type: 'text', text: JSON.stringify(pages, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_search_pages:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Page search');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error searching pages: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+    return {
+      content: [{ type: 'text', text: JSON.stringify(pages, null, 2) }],
+    };
+  })
 );
 
 // =============================================================================
@@ -1104,38 +937,14 @@ server.registerTool(
     description: 'Creates a new member (subscriber) in Ghost CMS.',
     inputSchema: createMemberSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(createMemberSchema, rawInput, 'ghost_create_member');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_create_member with email: ${input.email}`);
-    try {
-      await loadServices();
+  withErrorHandling('ghost_create_member', createMemberSchema, async (input) => {
+    const createdMember = await ghostService.createMember(input);
+    console.error(`Member created successfully. Member ID: ${createdMember.id}`);
 
-      const createdMember = await ghostService.createMember(input);
-      console.error(`Member created successfully. Member ID: ${createdMember.id}`);
-
-      return {
-        content: [{ type: 'text', text: JSON.stringify(createdMember, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_create_member:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Member creation');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error creating member: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+    return {
+      content: [{ type: 'text', text: JSON.stringify(createdMember, null, 2) }],
+    };
+  })
 );
 
 // Update Member Tool
@@ -1145,40 +954,16 @@ server.registerTool(
     description: 'Updates an existing member in Ghost CMS. All fields except id are optional.',
     inputSchema: updateMemberInputSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(updateMemberInputSchema, rawInput, 'ghost_update_member');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_update_member for member ID: ${input.id}`);
-    try {
-      await loadServices();
-
-      const { id, ...updateData } = input;
+  withErrorHandling('ghost_update_member', updateMemberInputSchema, async (input) => {
+    const { id, ...updateData } = input;
 
-      const updatedMember = await ghostService.updateMember(id, updateData);
-      console.error(`Member updated successfully. Member ID: ${updatedMember.id}`);
+    const updatedMember = await ghostService.updateMember(id, updateData);
+    console.error(`Member updated successfully. Member ID: ${updatedMember.id}`);
 
-      return {
-        content: [{ type: 'text', text: JSON.stringify(updatedMember, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_update_member:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Member update');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error updating member: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+    return {
+      content: [{ type: 'text', text: JSON.stringify(updatedMember, null, 2) }],
+    };
+  })
 );
 
 // Delete Member Tool
@@ -1189,38 +974,15 @@ server.registerTool(
       'Deletes a member from Ghost CMS by ID. This operation is permanent and cannot be undone.',
     inputSchema: deleteMemberSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(deleteMemberSchema, rawInput, 'ghost_delete_member');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const { id } = validation.data;
-
-    console.error(`Executing tool: ghost_delete_member for member ID: ${id}`);
-    try {
-      await loadServices();
-
-      await ghostService.deleteMember(id);
-      console.error(`Member deleted successfully. Member ID: ${id}`);
-
-      return {
-        content: [{ type: 'text', text: `Member ${id} has been successfully deleted.` }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_delete_member:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Member deletion');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error deleting member: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+  withErrorHandling('ghost_delete_member', deleteMemberSchema, async (input) => {
+    const { id } = input;
+    await ghostService.deleteMember(id);
+    console.error(`Member deleted successfully. Member ID: ${id}`);
+
+    return {
+      content: [{ type: 'text', text: `Member ${id} has been successfully deleted.` }],
+    };
+  })
 );
 
 // Get Members Tool
@@ -1231,45 +993,21 @@ server.registerTool(
       'Retrieves a list of members (subscribers) from Ghost CMS with optional filtering, pagination, and includes.',
     inputSchema: getMembersSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(getMembersSchema, rawInput, 'ghost_get_members');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_get_members`);
-    try {
-      await loadServices();
-
-      const options = {};
-      if (input.limit !== undefined) options.limit = input.limit;
-      if (input.page !== undefined) options.page = input.page;
-      if (input.filter !== undefined) options.filter = input.filter;
-      if (input.order !== undefined) options.order = input.order;
-      if (input.include !== undefined) options.include = input.include;
-
-      const members = await ghostService.getMembers(options);
-      console.error(`Retrieved ${members.length} members from Ghost.`);
-
-      return {
-        content: [{ type: 'text', text: JSON.stringify(members, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_get_members:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Member query');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error retrieving members: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+  withErrorHandling('ghost_get_members', getMembersSchema, async (input) => {
+    const options = {};
+    if (input.limit !== undefined) options.limit = input.limit;
+    if (input.page !== undefined) options.page = input.page;
+    if (input.filter !== undefined) options.filter = input.filter;
+    if (input.order !== undefined) options.order = input.order;
+    if (input.include !== undefined) options.include = input.include;
+
+    const members = await ghostService.getMembers(options);
+    console.error(`Retrieved ${members.length} members from Ghost.`);
+
+    return {
+      content: [{ type: 'text', text: JSON.stringify(members, null, 2) }],
+    };
+  })
 );
 
 // Get Member Tool
@@ -1280,38 +1018,15 @@ server.registerTool(
       'Retrieves a single member from Ghost CMS by ID or email. Provide either id OR email.',
     inputSchema: getMemberSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(getMemberSchema, rawInput, 'ghost_get_member');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const { id, email } = validation.data;
-
-    console.error(`Executing tool: ghost_get_member for ${id ? `ID: ${id}` : `email: ${email}`}`);
-    try {
-      await loadServices();
-
-      const member = await ghostService.getMember({ id, email });
-      console.error(`Retrieved member: ${member.email} (ID: ${member.id})`);
-
-      return {
-        content: [{ type: 'text', text: JSON.stringify(member, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_get_member:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Member lookup');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error retrieving member: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+  withErrorHandling('ghost_get_member', getMemberSchema, async (input) => {
+    const { id, email } = input;
+    const member = await ghostService.getMember({ id, email });
+    console.error(`Retrieved member: ${member.email} (ID: ${member.id})`);
+
+    return {
+      content: [{ type: 'text', text: JSON.stringify(member, null, 2) }],
+    };
+  })
 );
 
 // Search Members Tool
@@ -1321,41 +1036,18 @@ server.registerTool(
     description: 'Searches for members by name or email in Ghost CMS.',
     inputSchema: searchMembersSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(searchMembersSchema, rawInput, 'ghost_search_members');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const { query, limit } = validation.data;
-
-    console.error(`Executing tool: ghost_search_members with query: ${query}`);
-    try {
-      await loadServices();
-
-      const options = {};
-      if (limit !== undefined) options.limit = limit;
+  withErrorHandling('ghost_search_members', searchMembersSchema, async (input) => {
+    const { query, limit } = input;
+    const options = {};
+    if (limit !== undefined) options.limit = limit;
 
-      const members = await ghostService.searchMembers(query, options);
-      console.error(`Found ${members.length} members matching "${query}".`);
+    const members = await ghostService.searchMembers(query, options);
+    console.error(`Found ${members.length} members matching "${query}".`);
 
-      return {
-        content: [{ type: 'text', text: JSON.stringify(members, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_search_members:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Member search');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error searching members: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+    return {
+      content: [{ type: 'text', text: JSON.stringify(members, null, 2) }],
+    };
+  })
 );
 
 // =============================================================================
@@ -1374,44 +1066,20 @@ server.registerTool(
     description: 'Retrieves a list of newsletters from Ghost CMS with optional filtering.',
     inputSchema: newsletterQuerySchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(newsletterQuerySchema, rawInput, 'ghost_get_newsletters');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_get_newsletters`);
-    try {
-      await loadServices();
-
-      const options = {};
-      if (input.limit !== undefined) options.limit = input.limit;
-      if (input.page !== undefined) options.page = input.page;
-      if (input.filter !== undefined) options.filter = input.filter;
-      if (input.order !== undefined) options.order = input.order;
-
-      const newsletters = await ghostService.getNewsletters(options);
-      console.error(`Retrieved ${newsletters.length} newsletters from Ghost.`);
-
-      return {
-        content: [{ type: 'text', text: JSON.stringify(newsletters, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_get_newsletters:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Newsletter query');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error retrieving newsletters: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+  withErrorHandling('ghost_get_newsletters', newsletterQuerySchema, async (input) => {
+    const options = {};
+    if (input.limit !== undefined) options.limit = input.limit;
+    if (input.page !== undefined) options.page = input.page;
+    if (input.filter !== undefined) options.filter = input.filter;
+    if (input.order !== undefined) options.order = input.order;
+
+    const newsletters = await ghostService.getNewsletters(options);
+    console.error(`Retrieved ${newsletters.length} newsletters from Ghost.`);
+
+    return {
+      content: [{ type: 'text', text: JSON.stringify(newsletters, null, 2) }],
+    };
+  })
 );
 
 // Get Newsletter Tool
@@ -1421,38 +1089,15 @@ server.registerTool(
     description: 'Retrieves a single newsletter from Ghost CMS by ID.',
     inputSchema: getNewsletterSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(getNewsletterSchema, rawInput, 'ghost_get_newsletter');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const { id } = validation.data;
-
-    console.error(`Executing tool: ghost_get_newsletter for ID: ${id}`);
-    try {
-      await loadServices();
-
-      const newsletter = await ghostService.getNewsletter(id);
-      console.error(`Retrieved newsletter: ${newsletter.name} (ID: ${newsletter.id})`);
-
-      return {
-        content: [{ type: 'text', text: JSON.stringify(newsletter, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_get_newsletter:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Newsletter retrieval');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error retrieving newsletter: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+  withErrorHandling('ghost_get_newsletter', getNewsletterSchema, async (input) => {
+    const { id } = input;
+    const newsletter = await ghostService.getNewsletter(id);
+    console.error(`Retrieved newsletter: ${newsletter.name} (ID: ${newsletter.id})`);
+
+    return {
+      content: [{ type: 'text', text: JSON.stringify(newsletter, null, 2) }],
+    };
+  })
 );
 
 // Create Newsletter Tool
@@ -1463,42 +1108,14 @@ server.registerTool(
       'Creates a new newsletter in Ghost CMS with customizable sender settings and display options.',
     inputSchema: createNewsletterSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(
-      createNewsletterSchema,
-      rawInput,
-      'ghost_create_newsletter'
-    );
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_create_newsletter with name: ${input.name}`);
-    try {
-      await loadServices();
-
-      const createdNewsletter = await newsletterService.createNewsletterService(input);
-      console.error(`Newsletter created successfully. Newsletter ID: ${createdNewsletter.id}`);
+  withErrorHandling('ghost_create_newsletter', createNewsletterSchema, async (input) => {
+    const createdNewsletter = await newsletterService.createNewsletterService(input);
+    console.error(`Newsletter created successfully. Newsletter ID: ${createdNewsletter.id}`);
 
-      return {
-        content: [{ type: 'text', text: JSON.stringify(createdNewsletter, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_create_newsletter:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Newsletter creation');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error creating newsletter: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+    return {
+      content: [{ type: 'text', text: JSON.stringify(createdNewsletter, null, 2) }],
+    };
+  })
 );
 
 // Update Newsletter Tool
@@ -1509,44 +1126,16 @@ server.registerTool(
       'Updates an existing newsletter in Ghost CMS. Can update name, description, sender settings, and display options.',
     inputSchema: updateNewsletterInputSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(
-      updateNewsletterInputSchema,
-      rawInput,
-      'ghost_update_newsletter'
-    );
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_update_newsletter for newsletter ID: ${input.id}`);
-    try {
-      await loadServices();
-
-      const { id, ...updateData } = input;
+  withErrorHandling('ghost_update_newsletter', updateNewsletterInputSchema, async (input) => {
+    const { id, ...updateData } = input;
 
-      const updatedNewsletter = await ghostService.updateNewsletter(id, updateData);
-      console.error(`Newsletter updated successfully. Newsletter ID: ${updatedNewsletter.id}`);
+    const updatedNewsletter = await ghostService.updateNewsletter(id, updateData);
+    console.error(`Newsletter updated successfully. Newsletter ID: ${updatedNewsletter.id}`);
 
-      return {
-        content: [{ type: 'text', text: JSON.stringify(updatedNewsletter, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_update_newsletter:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Newsletter update');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error updating newsletter: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+    return {
+      content: [{ type: 'text', text: JSON.stringify(updatedNewsletter, null, 2) }],
+    };
+  })
 );
 
 // Delete Newsletter Tool
@@ -1557,42 +1146,15 @@ server.registerTool(
       'Deletes a newsletter from Ghost CMS by ID. This operation is permanent and cannot be undone.',
     inputSchema: deleteNewsletterSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(
-      deleteNewsletterSchema,
-      rawInput,
-      'ghost_delete_newsletter'
-    );
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const { id } = validation.data;
-
-    console.error(`Executing tool: ghost_delete_newsletter for newsletter ID: ${id}`);
-    try {
-      await loadServices();
-
-      await ghostService.deleteNewsletter(id);
-      console.error(`Newsletter deleted successfully. Newsletter ID: ${id}`);
-
-      return {
-        content: [{ type: 'text', text: `Newsletter ${id} has been successfully deleted.` }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_delete_newsletter:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Newsletter deletion');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error deleting newsletter: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+  withErrorHandling('ghost_delete_newsletter', deleteNewsletterSchema, async (input) => {
+    const { id } = input;
+    await ghostService.deleteNewsletter(id);
+    console.error(`Newsletter deleted successfully. Newsletter ID: ${id}`);
+
+    return {
+      content: [{ type: 'text', text: `Newsletter ${id} has been successfully deleted.` }],
+    };
+  })
 );
 
 // --- Tier Tools ---
@@ -1610,38 +1172,14 @@ server.registerTool(
       'Retrieves a list of tiers (membership levels) from Ghost CMS with optional filtering by type (free/paid).',
     inputSchema: tierQuerySchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(tierQuerySchema, rawInput, 'ghost_get_tiers');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
+  withErrorHandling('ghost_get_tiers', tierQuerySchema, async (input) => {
+    const tiers = await ghostService.getTiers(input);
+    console.error(`Retrieved ${tiers.length} tiers`);
 
-    console.error(`Executing tool: ghost_get_tiers`);
-    try {
-      await loadServices();
-
-      const tiers = await ghostService.getTiers(input);
-      console.error(`Retrieved ${tiers.length} tiers`);
-
-      return {
-        content: [{ type: 'text', text: JSON.stringify(tiers, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_get_tiers:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Tier query');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error getting tiers: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+    return {
+      content: [{ type: 'text', text: JSON.stringify(tiers, null, 2) }],
+    };
+  })
 );
 
 // Get Tier Tool
@@ -1651,38 +1189,15 @@ server.registerTool(
     description: 'Retrieves a single tier (membership level) from Ghost CMS by ID.',
     inputSchema: getTierSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(getTierSchema, rawInput, 'ghost_get_tier');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const { id } = validation.data;
-
-    console.error(`Executing tool: ghost_get_tier for tier ID: ${id}`);
-    try {
-      await loadServices();
-
-      const tier = await ghostService.getTier(id);
-      console.error(`Tier retrieved successfully. Tier ID: ${tier.id}`);
-
-      return {
-        content: [{ type: 'text', text: JSON.stringify(tier, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_get_tier:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Tier retrieval');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error getting tier: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+  withErrorHandling('ghost_get_tier', getTierSchema, async (input) => {
+    const { id } = input;
+    const tier = await ghostService.getTier(id);
+    console.error(`Tier retrieved successfully. Tier ID: ${tier.id}`);
+
+    return {
+      content: [{ type: 'text', text: JSON.stringify(tier, null, 2) }],
+    };
+  })
 );
 
 // Create Tier Tool
@@ -1692,38 +1207,14 @@ server.registerTool(
     description: 'Creates a new tier (membership level) in Ghost CMS with pricing and benefits.',
     inputSchema: createTierSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(createTierSchema, rawInput, 'ghost_create_tier');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_create_tier`);
-    try {
-      await loadServices();
-
-      const tier = await ghostService.createTier(input);
-      console.error(`Tier created successfully. Tier ID: ${tier.id}`);
+  withErrorHandling('ghost_create_tier', createTierSchema, async (input) => {
+    const tier = await ghostService.createTier(input);
+    console.error(`Tier created successfully. Tier ID: ${tier.id}`);
 
-      return {
-        content: [{ type: 'text', text: JSON.stringify(tier, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_create_tier:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Tier creation');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error creating tier: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+    return {
+      content: [{ type: 'text', text: JSON.stringify(tier, null, 2) }],
+    };
+  })
 );
 
 // Update Tier Tool
@@ -1734,40 +1225,16 @@ server.registerTool(
       'Updates an existing tier (membership level) in Ghost CMS. Can update pricing, benefits, and other tier properties.',
     inputSchema: updateTierInputSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(updateTierInputSchema, rawInput, 'ghost_update_tier');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const input = validation.data;
-
-    console.error(`Executing tool: ghost_update_tier for tier ID: ${input.id}`);
-    try {
-      await loadServices();
-
-      const { id, ...updateData } = input;
+  withErrorHandling('ghost_update_tier', updateTierInputSchema, async (input) => {
+    const { id, ...updateData } = input;
 
-      const updatedTier = await ghostService.updateTier(id, updateData);
-      console.error(`Tier updated successfully. Tier ID: ${updatedTier.id}`);
+    const updatedTier = await ghostService.updateTier(id, updateData);
+    console.error(`Tier updated successfully. Tier ID: ${updatedTier.id}`);
 
-      return {
-        content: [{ type: 'text', text: JSON.stringify(updatedTier, null, 2) }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_update_tier:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Tier update');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error updating tier: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+    return {
+      content: [{ type: 'text', text: JSON.stringify(updatedTier, null, 2) }],
+    };
+  })
 );
 
 // Delete Tier Tool
@@ -1778,38 +1245,15 @@ server.registerTool(
       'Deletes a tier (membership level) from Ghost CMS by ID. This operation is permanent and cannot be undone.',
     inputSchema: deleteTierSchema,
   },
-  async (rawInput) => {
-    const validation = validateToolInput(deleteTierSchema, rawInput, 'ghost_delete_tier');
-    if (!validation.success) {
-      return validation.errorResponse;
-    }
-    const { id } = validation.data;
-
-    console.error(`Executing tool: ghost_delete_tier for tier ID: ${id}`);
-    try {
-      await loadServices();
-
-      await ghostService.deleteTier(id);
-      console.error(`Tier deleted successfully. Tier ID: ${id}`);
-
-      return {
-        content: [{ type: 'text', text: `Tier ${id} has been successfully deleted.` }],
-      };
-    } catch (error) {
-      console.error(`Error in ghost_delete_tier:`, error);
-      if (error.name === 'ZodError') {
-        const validationError = ValidationError.fromZod(error, 'Tier deletion');
-        return {
-          content: [{ type: 'text', text: JSON.stringify(validationError.toJSON(), null, 2) }],
-          isError: true,
-        };
-      }
-      return {
-        content: [{ type: 'text', text: `Error deleting tier: ${error.message}` }],
-        isError: true,
-      };
-    }
-  }
+  withErrorHandling('ghost_delete_tier', deleteTierSchema, async (input) => {
+    const { id } = input;
+    await ghostService.deleteTier(id);
+    console.error(`Tier deleted successfully. Tier ID: ${id}`);
+
+    return {
+      content: [{ type: 'text', text: `Tier ${id} has been successfully deleted.` }],
+    };
+  })
 );
 
 // --- Main Entry Point ---