@thelord/mcp-arr 1.3.0 → 1.5.0

package/dist/index.js

@@ -572,6 +572,99 @@ if (clients.sonarr) {
             },
             required: ["tagId"],
         },
+    }, {
+        name: "sonarr_get_history",
+        description: "Get Sonarr download/import history",
+        inputSchema: {
+            type: "object",
+            properties: {
+                page: {
+                    type: "number",
+                    description: "Page number (default: 1)",
+                },
+                pageSize: {
+                    type: "number",
+                    description: "Items per page (default: 20)",
+                },
+                seriesId: {
+                    type: "number",
+                    description: "Optional: filter to specific series ID",
+                },
+            },
+            required: [],
+        },
+    }, {
+        name: "sonarr_get_wanted",
+        description: "Get list of missing/wanted episodes",
+        inputSchema: {
+            type: "object",
+            properties: {
+                page: {
+                    type: "number",
+                    description: "Page number (default: 1)",
+                },
+                pageSize: {
+                    type: "number",
+                    description: "Items per page (default: 20)",
+                },
+            },
+            required: [],
+        },
+    }, {
+        name: "sonarr_get_cutoff_unmet",
+        description: "Get episodes with quality below cutoff that could be upgraded",
+        inputSchema: {
+            type: "object",
+            properties: {
+                page: {
+                    type: "number",
+                    description: "Page number (default: 1)",
+                },
+                pageSize: {
+                    type: "number",
+                    description: "Items per page (default: 20)",
+                },
+            },
+            required: [],
+        },
+    }, {
+        name: "sonarr_get_blocklist",
+        description: "Get blocklisted releases (releases that failed or were manually blocklisted)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                page: {
+                    type: "number",
+                    description: "Page number (default: 1)",
+                },
+                pageSize: {
+                    type: "number",
+                    description: "Items per page (default: 20)",
+                },
+            },
+            required: [],
+        },
+    }, {
+        name: "sonarr_delete_blocklist_item",
+        description: "Remove an item from the blocklist",
+        inputSchema: {
+            type: "object",
+            properties: {
+                blocklistId: {
+                    type: "number",
+                    description: "Blocklist item ID to delete",
+                },
+            },
+            required: ["blocklistId"],
+        },
+    }, {
+        name: "sonarr_search_all_missing",
+        description: "Trigger a search for all missing episodes across all series",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
     });
 }
 // Radarr tools
@@ -619,190 +712,526 @@ if (clients.radarr) {
             required: [],
         },
     }, {
-        name: "radarr_search_movie",
-        description: "Trigger a search to download a movie that's already in your library",
+        name: "radarr_add_movie",
+        description: "Add a new movie to Radarr",
         inputSchema: {
             type: "object",
             properties: {
-                movieId: {
+                tmdbId: {
                     type: "number",
-                    description: "Movie ID to search for",
+                    description: "TMDB ID for the movie (get from radarr_search)",
+                },
+                title: {
+                    type: "string",
+                    description: "Movie title",
+                },
+                qualityProfileId: {
+                    type: "number",
+                    description: "Quality profile ID (get from radarr_get_quality_profiles)",
+                },
+                rootFolderPath: {
+                    type: "string",
+                    description: "Root folder path (get from radarr_get_root_folders)",
+                },
+                monitored: {
+                    type: "boolean",
+                    description: "Monitor movie (default: true)",
+                },
+                minimumAvailability: {
+                    type: "string",
+                    description: "When to consider movie available: announced, inCinemas, released (default: released)",
+                },
+                tags: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "Tag IDs to apply",
                 },
             },
-            required: ["movieId"],
+            required: ["tmdbId", "qualityProfileId", "rootFolderPath"],
         },
-    });
-}
-// Lidarr tools
-if (clients.lidarr) {
-    TOOLS.push({
-        name: "lidarr_get_artists",
-        description: "Get all artists in Lidarr library",
+    }, {
+        name: "radarr_update_movie",
+        description: "Update an existing movie configuration (monitored, tags, quality profile, etc.)",
         inputSchema: {
             type: "object",
-            properties: {},
-            required: [],
+            properties: {
+                movieId: {
+                    type: "number",
+                    description: "Movie ID to update",
+                },
+                monitored: {
+                    type: "boolean",
+                    description: "Monitor movie",
+                },
+                qualityProfileId: {
+                    type: "number",
+                    description: "Quality profile ID",
+                },
+                minimumAvailability: {
+                    type: "string",
+                    description: "Minimum availability: announced, inCinemas, released",
+                },
+                tags: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "Tag IDs to apply",
+                },
+            },
+            required: ["movieId"],
         },
     }, {
-        name: "lidarr_search",
-        description: "Search for artists to add to Lidarr",
+        name: "radarr_delete_movie",
+        description: "Delete a movie from Radarr library. Optionally delete files and add to exclusion list.",
         inputSchema: {
             type: "object",
             properties: {
-                term: {
-                    type: "string",
-                    description: "Search term (artist name)",
+                movieId: {
+                    type: "number",
+                    description: "Movie ID to delete",
+                },
+                deleteFiles: {
+                    type: "boolean",
+                    description: "Delete all files for this movie (default: false)",
+                },
+                addImportExclusion: {
+                    type: "boolean",
+                    description: "Add movie to import exclusion list (default: false)",
                 },
             },
-            required: ["term"],
+            required: ["movieId"],
         },
     }, {
-        name: "lidarr_get_queue",
-        description: "Get Lidarr download queue",
+        name: "radarr_search_movie",
+        description: "Trigger a search to download a movie that's already in your library",
         inputSchema: {
             type: "object",
-            properties: {},
-            required: [],
+            properties: {
+                movieId: {
+                    type: "number",
+                    description: "Movie ID to search for",
+                },
+            },
+            required: ["movieId"],
         },
     }, {
-        name: "lidarr_get_albums",
-        description: "Get albums for an artist in Lidarr. Shows which albums are available and which are missing.",
+        name: "radarr_get_history",
+        description: "Get Radarr download/import history",
         inputSchema: {
             type: "object",
             properties: {
-                artistId: {
+                page: {
                     type: "number",
-                    description: "Artist ID to get albums for",
+                    description: "Page number (default: 1)",
+                },
+                pageSize: {
+                    type: "number",
+                    description: "Items per page (default: 20)",
+                },
+                movieId: {
+                    type: "number",
+                    description: "Optional: filter to specific movie ID",
                 },
             },
-            required: ["artistId"],
+            required: [],
         },
     }, {
-        name: "lidarr_search_album",
-        description: "Trigger a search for a specific album to download",
+        name: "radarr_refresh_movie",
+        description: "Refresh movie metadata from TMDB",
         inputSchema: {
             type: "object",
             properties: {
-                albumId: {
+                movieId: {
                     type: "number",
-                    description: "Album ID to search for",
+                    description: "Movie ID to refresh",
                 },
             },
-            required: ["albumId"],
+            required: ["movieId"],
         },
     }, {
-        name: "lidarr_search_missing",
-        description: "Trigger a search for all missing albums for an artist",
+        name: "radarr_rescan_movie",
+        description: "Rescan movie disk for new/changed files",
         inputSchema: {
             type: "object",
             properties: {
-                artistId: {
+                movieId: {
                     type: "number",
-                    description: "Artist ID to search missing albums for",
+                    description: "Movie ID to rescan",
                 },
             },
-            required: ["artistId"],
+            required: ["movieId"],
         },
     }, {
-        name: "lidarr_get_calendar",
-        description: "Get upcoming album releases from Lidarr",
+        name: "radarr_rename_movie",
+        description: "Rename movie files according to Radarr naming conventions",
         inputSchema: {
             type: "object",
             properties: {
-                days: {
+                movieId: {
                     type: "number",
-                    description: "Number of days to look ahead (default: 30)",
+                    description: "Movie ID to rename",
                 },
             },
-            required: [],
+            required: ["movieId"],
         },
-    });
-}
-// Readarr tools
-if (clients.readarr) {
-    TOOLS.push({
-        name: "readarr_get_authors",
-        description: "Get all authors in Readarr library",
+    }, {
+        name: "radarr_get_collections",
+        description: "Get all movie collections in Radarr",
         inputSchema: {
             type: "object",
             properties: {},
             required: [],
         },
     }, {
-        name: "readarr_search",
-        description: "Search for authors to add to Readarr",
+        name: "radarr_update_collection",
+        description: "Update a collection (monitored status, quality profile, root folder)",
         inputSchema: {
             type: "object",
             properties: {
-                term: {
+                collectionId: {
+                    type: "number",
+                    description: "Collection ID to update",
+                },
+                monitored: {
+                    type: "boolean",
+                    description: "Monitor collection (automatically add new movies)",
+                },
+                qualityProfileId: {
+                    type: "number",
+                    description: "Quality profile ID for new movies",
+                },
+                rootFolderPath: {
                     type: "string",
-                    description: "Search term (author name)",
+                    description: "Root folder for new movies",
+                },
+                searchOnAdd: {
+                    type: "boolean",
+                    description: "Search for movies when added from collection",
                 },
             },
-            required: ["term"],
+            required: ["collectionId"],
         },
     }, {
-        name: "readarr_get_queue",
-        description: "Get Readarr download queue",
+        name: "radarr_get_movie_files",
+        description: "Get movie file details including quality, size, and media info",
         inputSchema: {
             type: "object",
-            properties: {},
-            required: [],
+            properties: {
+                movieId: {
+                    type: "number",
+                    description: "Movie ID to get files for",
+                },
+            },
+            required: ["movieId"],
         },
     }, {
-        name: "readarr_get_books",
-        description: "Get books for an author in Readarr. Shows which books are available and which are missing.",
+        name: "radarr_delete_movie_file",
+        description: "Delete a movie file. Useful for removing bad quality files to force re-download.",
         inputSchema: {
             type: "object",
             properties: {
-                authorId: {
+                movieFileId: {
                     type: "number",
-                    description: "Author ID to get books for",
+                    description: "Movie file ID to delete",
                 },
             },
-            required: ["authorId"],
+            required: ["movieFileId"],
         },
     }, {
-        name: "readarr_search_book",
-        description: "Trigger a search for a specific book to download",
+        name: "radarr_get_blocklist",
+        description: "Get blocklisted releases (releases that failed or were manually blocklisted)",
         inputSchema: {
             type: "object",
             properties: {
-                bookIds: {
-                    type: "array",
-                    items: { type: "number" },
-                    description: "Book ID(s) to search for",
+                page: {
+                    type: "number",
+                    description: "Page number (default: 1)",
+                },
+                pageSize: {
+                    type: "number",
+                    description: "Items per page (default: 20)",
                 },
             },
-            required: ["bookIds"],
+            required: [],
         },
     }, {
-        name: "readarr_search_missing",
-        description: "Trigger a search for all missing books for an author",
+        name: "radarr_delete_blocklist_item",
+        description: "Remove an item from the blocklist",
         inputSchema: {
             type: "object",
             properties: {
-                authorId: {
+                blocklistId: {
                     type: "number",
-                    description: "Author ID to search missing books for",
+                    description: "Blocklist item ID to delete",
                 },
             },
-            required: ["authorId"],
+            required: ["blocklistId"],
         },
     }, {
-        name: "readarr_get_calendar",
-        description: "Get upcoming book releases from Readarr",
+        name: "radarr_get_extra_files",
+        description: "Get extra files for a movie (subtitles, nfo files, etc.)",
         inputSchema: {
             type: "object",
             properties: {
-                days: {
+                movieId: {
                     type: "number",
-                    description: "Number of days to look ahead (default: 30)",
+                    description: "Movie ID to get extra files for",
                 },
             },
-            required: [],
+            required: ["movieId"],
         },
-    });
+    }, {
+        name: "radarr_get_credits",
+        description: "Get cast and crew credits for a movie",
+        inputSchema: {
+            type: "object",
+            properties: {
+                movieId: {
+                    type: "number",
+                    description: "Movie ID to get credits for",
+                },
+            },
+            required: ["movieId"],
+        },
+    }, {
+        name: "radarr_get_wanted",
+        description: "Get list of missing/wanted movies",
+        inputSchema: {
+            type: "object",
+            properties: {
+                page: {
+                    type: "number",
+                    description: "Page number (default: 1)",
+                },
+                pageSize: {
+                    type: "number",
+                    description: "Items per page (default: 20)",
+                },
+            },
+            required: [],
+        },
+    }, {
+        name: "radarr_search_missing",
+        description: "Trigger a search for all missing/wanted movies",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "radarr_create_tag",
+        description: "Create a new tag",
+        inputSchema: {
+            type: "object",
+            properties: {
+                label: {
+                    type: "string",
+                    description: "Tag label/name",
+                },
+            },
+            required: ["label"],
+        },
+    }, {
+        name: "radarr_update_tag",
+        description: "Update a tag label",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tagId: {
+                    type: "number",
+                    description: "Tag ID to update",
+                },
+                label: {
+                    type: "string",
+                    description: "New tag label",
+                },
+            },
+            required: ["tagId", "label"],
+        },
+    }, {
+        name: "radarr_delete_tag",
+        description: "Delete a tag",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tagId: {
+                    type: "number",
+                    description: "Tag ID to delete",
+                },
+            },
+            required: ["tagId"],
+        },
+    });
+}
+// Lidarr tools
+if (clients.lidarr) {
+    TOOLS.push({
+        name: "lidarr_get_artists",
+        description: "Get all artists in Lidarr library",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "lidarr_search",
+        description: "Search for artists to add to Lidarr",
+        inputSchema: {
+            type: "object",
+            properties: {
+                term: {
+                    type: "string",
+                    description: "Search term (artist name)",
+                },
+            },
+            required: ["term"],
+        },
+    }, {
+        name: "lidarr_get_queue",
+        description: "Get Lidarr download queue",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "lidarr_get_albums",
+        description: "Get albums for an artist in Lidarr. Shows which albums are available and which are missing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                artistId: {
+                    type: "number",
+                    description: "Artist ID to get albums for",
+                },
+            },
+            required: ["artistId"],
+        },
+    }, {
+        name: "lidarr_search_album",
+        description: "Trigger a search for a specific album to download",
+        inputSchema: {
+            type: "object",
+            properties: {
+                albumId: {
+                    type: "number",
+                    description: "Album ID to search for",
+                },
+            },
+            required: ["albumId"],
+        },
+    }, {
+        name: "lidarr_search_missing",
+        description: "Trigger a search for all missing albums for an artist",
+        inputSchema: {
+            type: "object",
+            properties: {
+                artistId: {
+                    type: "number",
+                    description: "Artist ID to search missing albums for",
+                },
+            },
+            required: ["artistId"],
+        },
+    }, {
+        name: "lidarr_get_calendar",
+        description: "Get upcoming album releases from Lidarr",
+        inputSchema: {
+            type: "object",
+            properties: {
+                days: {
+                    type: "number",
+                    description: "Number of days to look ahead (default: 30)",
+                },
+            },
+            required: [],
+        },
+    });
+}
+// Readarr tools
+if (clients.readarr) {
+    TOOLS.push({
+        name: "readarr_get_authors",
+        description: "Get all authors in Readarr library",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "readarr_search",
+        description: "Search for authors to add to Readarr",
+        inputSchema: {
+            type: "object",
+            properties: {
+                term: {
+                    type: "string",
+                    description: "Search term (author name)",
+                },
+            },
+            required: ["term"],
+        },
+    }, {
+        name: "readarr_get_queue",
+        description: "Get Readarr download queue",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "readarr_get_books",
+        description: "Get books for an author in Readarr. Shows which books are available and which are missing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                authorId: {
+                    type: "number",
+                    description: "Author ID to get books for",
+                },
+            },
+            required: ["authorId"],
+        },
+    }, {
+        name: "readarr_search_book",
+        description: "Trigger a search for a specific book to download",
+        inputSchema: {
+            type: "object",
+            properties: {
+                bookIds: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "Book ID(s) to search for",
+                },
+            },
+            required: ["bookIds"],
+        },
+    }, {
+        name: "readarr_search_missing",
+        description: "Trigger a search for all missing books for an author",
+        inputSchema: {
+            type: "object",
+            properties: {
+                authorId: {
+                    type: "number",
+                    description: "Author ID to search missing books for",
+                },
+            },
+            required: ["authorId"],
+        },
+    }, {
+        name: "readarr_get_calendar",
+        description: "Get upcoming book releases from Readarr",
+        inputSchema: {
+            type: "object",
+            properties: {
+                days: {
+                    type: "number",
+                    description: "Number of days to look ahead (default: 30)",
+                },
+            },
+            required: [],
+        },
+    });
 }
 // Prowlarr tools
 if (clients.prowlarr) {
@@ -843,20 +1272,274 @@ if (clients.prowlarr) {
             properties: {},
             required: [],
         },
-    });
-}
-// Lingarr tools - imported from separate module to reduce merge conflicts
-if (clients.lingarr) {
-    TOOLS.push(...getLingarrTools());
-}
-// Bazarr tools - imported from separate module
-if (clients.bazarr) {
-    TOOLS.push(...bazarrTools);
-}
-// Cross-service search tool
-TOOLS.push({
-    name: "arr_search_all",
-    description: "Search across all configured *arr services for any media",
+    }, {
+        name: "prowlarr_get_indexer",
+        description: "Get a specific indexer by ID",
+        inputSchema: {
+            type: "object",
+            properties: {
+                indexerId: {
+                    type: "number",
+                    description: "Indexer ID",
+                },
+            },
+            required: ["indexerId"],
+        },
+    }, {
+        name: "prowlarr_update_indexer",
+        description: "Update an indexer (enable/disable, priority, tags)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                indexerId: {
+                    type: "number",
+                    description: "Indexer ID to update",
+                },
+                enable: {
+                    type: "boolean",
+                    description: "Enable or disable the indexer",
+                },
+                priority: {
+                    type: "number",
+                    description: "Indexer priority (1-50, lower is higher priority)",
+                },
+                tags: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "Tag IDs to apply",
+                },
+            },
+            required: ["indexerId"],
+        },
+    }, {
+        name: "prowlarr_delete_indexer",
+        description: "Delete an indexer from Prowlarr",
+        inputSchema: {
+            type: "object",
+            properties: {
+                indexerId: {
+                    type: "number",
+                    description: "Indexer ID to delete",
+                },
+            },
+            required: ["indexerId"],
+        },
+    }, {
+        name: "prowlarr_test_indexer",
+        description: "Test a specific indexer connection",
+        inputSchema: {
+            type: "object",
+            properties: {
+                indexerId: {
+                    type: "number",
+                    description: "Indexer ID to test",
+                },
+            },
+            required: ["indexerId"],
+        },
+    }, {
+        name: "prowlarr_get_applications",
+        description: "Get all applications (Sonarr, Radarr, etc. connections)",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "prowlarr_get_application",
+        description: "Get a specific application by ID",
+        inputSchema: {
+            type: "object",
+            properties: {
+                applicationId: {
+                    type: "number",
+                    description: "Application ID",
+                },
+            },
+            required: ["applicationId"],
+        },
+    }, {
+        name: "prowlarr_update_application",
+        description: "Update an application connection",
+        inputSchema: {
+            type: "object",
+            properties: {
+                applicationId: {
+                    type: "number",
+                    description: "Application ID to update",
+                },
+                syncLevel: {
+                    type: "string",
+                    description: "Sync level: disabled, addOnly, fullSync",
+                },
+                tags: {
+                    type: "array",
+                    items: { type: "number" },
+                    description: "Tag IDs to apply",
+                },
+            },
+            required: ["applicationId"],
+        },
+    }, {
+        name: "prowlarr_delete_application",
+        description: "Delete an application from Prowlarr",
+        inputSchema: {
+            type: "object",
+            properties: {
+                applicationId: {
+                    type: "number",
+                    description: "Application ID to delete",
+                },
+            },
+            required: ["applicationId"],
+        },
+    }, {
+        name: "prowlarr_test_application",
+        description: "Test an application connection",
+        inputSchema: {
+            type: "object",
+            properties: {
+                applicationId: {
+                    type: "number",
+                    description: "Application ID to test",
+                },
+            },
+            required: ["applicationId"],
+        },
+    }, {
+        name: "prowlarr_sync_applications",
+        description: "Sync indexers to all applications (push indexer config to Sonarr/Radarr/etc.)",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "prowlarr_get_app_profiles",
+        description: "Get app sync profiles (control which indexers sync to which apps)",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "prowlarr_get_history",
+        description: "Get Prowlarr history (searches, grabs, failures)",
+        inputSchema: {
+            type: "object",
+            properties: {
+                page: {
+                    type: "number",
+                    description: "Page number (default: 1)",
+                },
+                pageSize: {
+                    type: "number",
+                    description: "Items per page (default: 20)",
+                },
+                indexerId: {
+                    type: "number",
+                    description: "Filter by indexer ID",
+                },
+            },
+            required: [],
+        },
+    }, {
+        name: "prowlarr_get_tags",
+        description: "Get all tags defined in Prowlarr",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "prowlarr_create_tag",
+        description: "Create a new tag in Prowlarr",
+        inputSchema: {
+            type: "object",
+            properties: {
+                label: {
+                    type: "string",
+                    description: "Tag label/name",
+                },
+            },
+            required: ["label"],
+        },
+    }, {
+        name: "prowlarr_update_tag",
+        description: "Update a tag label in Prowlarr",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tagId: {
+                    type: "number",
+                    description: "Tag ID to update",
+                },
+                label: {
+                    type: "string",
+                    description: "New tag label",
+                },
+            },
+            required: ["tagId", "label"],
+        },
+    }, {
+        name: "prowlarr_delete_tag",
+        description: "Delete a tag from Prowlarr",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tagId: {
+                    type: "number",
+                    description: "Tag ID to delete",
+                },
+            },
+            required: ["tagId"],
+        },
+    }, {
+        name: "prowlarr_get_indexer_schemas",
+        description: "Get available indexer schemas (templates for adding new indexers)",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "prowlarr_get_notifications",
+        description: "Get configured notification connections",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "prowlarr_rss_sync",
+        description: "Trigger RSS sync for all indexers",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    }, {
+        name: "prowlarr_get_download_clients",
+        description: "Get configured download clients",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    });
+}
+// Lingarr tools - imported from separate module to reduce merge conflicts
+if (clients.lingarr) {
+    TOOLS.push(...getLingarrTools());
+}
+// Bazarr tools - imported from separate module
+if (clients.bazarr) {
+    TOOLS.push(...bazarrTools);
+}
+// Cross-service search tool
+TOOLS.push({
+    name: "arr_search_all",
+    description: "Search across all configured *arr services for any media",
     inputSchema: {
         type: "object",
         properties: {
@@ -1182,193 +1865,770 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
-                                count: downloadClients.length,
-                                clients: downloadClients.map((c) => ({
-                                    id: c.id,
-                                    name: c.name,
-                                    implementation: c.implementationName,
-                                    protocol: c.protocol,
-                                    enabled: c.enable,
-                                    priority: c.priority,
-                                    removeCompletedDownloads: c.removeCompletedDownloads,
-                                    removeFailedDownloads: c.removeFailedDownloads,
-                                    tags: c.tags,
+                                count: downloadClients.length,
+                                clients: downloadClients.map((c) => ({
+                                    id: c.id,
+                                    name: c.name,
+                                    implementation: c.implementationName,
+                                    protocol: c.protocol,
+                                    enabled: c.enable,
+                                    priority: c.priority,
+                                    removeCompletedDownloads: c.removeCompletedDownloads,
+                                    removeFailedDownloads: c.removeFailedDownloads,
+                                    tags: c.tags,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            // Naming config
+            case "sonarr_get_naming":
+            case "radarr_get_naming":
+            case "lidarr_get_naming":
+            case "readarr_get_naming": {
+                const serviceName = name.split('_')[0];
+                const client = clients[serviceName];
+                if (!client)
+                    throw new Error(`${serviceName} not configured`);
+                const naming = await client.getNamingConfig();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(naming, null, 2),
+                        }],
+                };
+            }
+            // Tags
+            case "sonarr_get_tags":
+            case "radarr_get_tags":
+            case "lidarr_get_tags":
+            case "readarr_get_tags": {
+                const serviceName = name.split('_')[0];
+                const client = clients[serviceName];
+                if (!client)
+                    throw new Error(`${serviceName} not configured`);
+                const tags = await client.getTags();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                count: tags.length,
+                                tags: tags.map((t) => ({ id: t.id, label: t.label })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            // Comprehensive setup review
+            case "sonarr_review_setup":
+            case "radarr_review_setup":
+            case "lidarr_review_setup":
+            case "readarr_review_setup": {
+                const serviceName = name.split('_')[0];
+                const client = clients[serviceName];
+                if (!client)
+                    throw new Error(`${serviceName} not configured`);
+                // Gather all configuration data
+                const [status, health, qualityProfiles, qualityDefinitions, downloadClients, naming, mediaManagement, rootFolders, tags, indexers] = await Promise.all([
+                    client.getStatus(),
+                    client.getHealth(),
+                    client.getQualityProfiles(),
+                    client.getQualityDefinitions(),
+                    client.getDownloadClients(),
+                    client.getNamingConfig(),
+                    client.getMediaManagement(),
+                    client.getRootFoldersDetailed(),
+                    client.getTags(),
+                    client.getIndexers(),
+                ]);
+                // For Lidarr/Readarr, also get metadata profiles
+                let metadataProfiles = null;
+                if (serviceName === 'lidarr' && clients.lidarr) {
+                    metadataProfiles = await clients.lidarr.getMetadataProfiles();
+                }
+                else if (serviceName === 'readarr' && clients.readarr) {
+                    metadataProfiles = await clients.readarr.getMetadataProfiles();
+                }
+                const review = {
+                    service: serviceName,
+                    version: status.version,
+                    appName: status.appName,
+                    platform: {
+                        os: status.osName,
+                        isDocker: status.isDocker,
+                    },
+                    health: {
+                        issueCount: health.length,
+                        issues: health,
+                    },
+                    storage: {
+                        rootFolders: rootFolders.map((f) => ({
+                            path: f.path,
+                            accessible: f.accessible,
+                            freeSpace: formatBytes(f.freeSpace),
+                            freeSpaceBytes: f.freeSpace,
+                            unmappedFolderCount: f.unmappedFolders?.length || 0,
+                        })),
+                    },
+                    qualityProfiles: qualityProfiles.map((p) => ({
+                        id: p.id,
+                        name: p.name,
+                        upgradeAllowed: p.upgradeAllowed,
+                        cutoff: p.cutoff,
+                        allowedQualities: p.items
+                            .filter((i) => i.allowed)
+                            .map((i) => i.quality?.name || i.name || (i.items?.map((q) => q.quality.name).join(', ')))
+                            .filter(Boolean),
+                        customFormatsWithScores: p.formatItems?.filter((f) => f.score !== 0).length || 0,
+                        minFormatScore: p.minFormatScore,
+                    })),
+                    qualityDefinitions: qualityDefinitions.map((d) => ({
+                        quality: d.quality.name,
+                        minSize: d.minSize + ' MB/min',
+                        maxSize: d.maxSize === 0 ? 'unlimited' : d.maxSize + ' MB/min',
+                        preferredSize: d.preferredSize + ' MB/min',
+                    })),
+                    downloadClients: downloadClients.map((c) => ({
+                        name: c.name,
+                        type: c.implementationName,
+                        protocol: c.protocol,
+                        enabled: c.enable,
+                        priority: c.priority,
+                    })),
+                    indexers: indexers.map((i) => ({
+                        name: i.name,
+                        protocol: i.protocol,
+                        enableRss: i.enableRss,
+                        enableAutomaticSearch: i.enableAutomaticSearch,
+                        enableInteractiveSearch: i.enableInteractiveSearch,
+                        priority: i.priority,
+                    })),
+                    naming: naming,
+                    mediaManagement: {
+                        recycleBin: mediaManagement.recycleBin || 'not set',
+                        recycleBinCleanupDays: mediaManagement.recycleBinCleanupDays,
+                        downloadPropersAndRepacks: mediaManagement.downloadPropersAndRepacks,
+                        deleteEmptyFolders: mediaManagement.deleteEmptyFolders,
+                        copyUsingHardlinks: mediaManagement.copyUsingHardlinks,
+                        importExtraFiles: mediaManagement.importExtraFiles,
+                        extraFileExtensions: mediaManagement.extraFileExtensions,
+                    },
+                    tags: tags.map((t) => t.label),
+                    ...(metadataProfiles && { metadataProfiles }),
+                };
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(review, null, 2),
+                        }],
+                };
+            }
+            // Sonarr handlers
+            case "sonarr_get_series": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const series = await clients.sonarr.getSeries();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                count: series.length,
+                                series: series.map(s => ({
+                                    id: s.id,
+                                    title: s.title,
+                                    year: s.year,
+                                    status: s.status,
+                                    network: s.network,
+                                    seasons: s.statistics?.seasonCount,
+                                    episodes: s.statistics?.episodeFileCount + '/' + s.statistics?.totalEpisodeCount,
+                                    sizeOnDisk: formatBytes(s.statistics?.sizeOnDisk || 0),
+                                    monitored: s.monitored,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_search": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const term = args.term;
+                const results = await clients.sonarr.searchSeries(term);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                count: results.length,
+                                results: results.slice(0, 10).map(r => ({
+                                    title: r.title,
+                                    year: r.year,
+                                    tvdbId: r.tvdbId,
+                                    overview: r.overview?.substring(0, 200) + (r.overview && r.overview.length > 200 ? '...' : ''),
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_get_queue": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const queue = await clients.sonarr.getQueue();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                totalRecords: queue.totalRecords,
+                                items: queue.records.map(q => ({
+                                    title: q.title,
+                                    status: q.status,
+                                    progress: ((1 - q.sizeleft / q.size) * 100).toFixed(1) + '%',
+                                    timeLeft: q.timeleft,
+                                    downloadClient: q.downloadClient,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_get_calendar": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const days = args?.days || 7;
+                const start = new Date().toISOString().split('T')[0];
+                const end = new Date(Date.now() + days * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
+                const calendar = await clients.sonarr.getCalendar(start, end);
+                return {
+                    content: [{ type: "text", text: JSON.stringify(calendar, null, 2) }],
+                };
+            }
+            case "sonarr_get_episodes": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { seriesId, seasonNumber } = args;
+                const episodes = await clients.sonarr.getEpisodes(seriesId, seasonNumber);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                count: episodes.length,
+                                episodes: episodes.map(e => ({
+                                    id: e.id,
+                                    seasonNumber: e.seasonNumber,
+                                    episodeNumber: e.episodeNumber,
+                                    title: e.title,
+                                    airDate: e.airDate,
+                                    hasFile: e.hasFile,
+                                    monitored: e.monitored,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_search_missing": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const seriesId = args.seriesId;
+                const result = await clients.sonarr.searchMissing(seriesId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Search triggered for missing episodes`,
+                                commandId: result.id,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_search_episode": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const episodeIds = args.episodeIds;
+                const result = await clients.sonarr.searchEpisode(episodeIds);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Search triggered for ${episodeIds.length} episode(s)`,
+                                commandId: result.id,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_add_series": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { tvdbId, title, qualityProfileId, rootFolderPath, seasonFolder, monitored, tags } = args;
+                const series = await clients.sonarr.addSeries({
+                    tvdbId,
+                    title,
+                    qualityProfileId,
+                    rootFolderPath,
+                    seasonFolder,
+                    monitored,
+                    tags,
+                });
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Series '${title}' added to Sonarr`,
+                                seriesId: series.id,
+                                series: {
+                                    id: series.id,
+                                    title: series.title,
+                                    path: series.path,
+                                    monitored: series.monitored,
+                                },
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_update_series": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { seriesId, ...updates } = args;
+                const series = await clients.sonarr.updateSeries(seriesId, updates);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Series '${series.title}' updated`,
+                                seriesId: series.id,
+                                updates: Object.keys(updates),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_delete_series": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { seriesId, deleteFiles = false, addImportListExclusion = false } = args;
+                await clients.sonarr.deleteSeries(seriesId, deleteFiles, addImportListExclusion);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Series deleted (files: ${deleteFiles}, exclude: ${addImportListExclusion})`,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_update_episode": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { episodeId, monitored } = args;
+                const episode = await clients.sonarr.updateEpisode(episodeId, { monitored });
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Episode ${episodeId} ${monitored ? 'monitored' : 'unmonitored'}`,
+                                episodeId: episode.id,
+                                monitored: episode.monitored,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_delete_episode_file": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { episodeFileId } = args;
+                await clients.sonarr.deleteEpisodeFile(episodeFileId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Episode file ${episodeFileId} deleted`,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_refresh_series": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { seriesId } = args;
+                const result = await clients.sonarr.refreshSeries(seriesId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Series ${seriesId} metadata refresh triggered`,
+                                commandId: result.id,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_rescan_series": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { seriesId } = args;
+                const result = await clients.sonarr.rescanSeries(seriesId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Series ${seriesId} disk rescan triggered`,
+                                commandId: result.id,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_rename_series": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { seriesId } = args;
+                const result = await clients.sonarr.renameSeries(seriesId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Series ${seriesId} files will be renamed`,
+                                commandId: result.id,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_rename_episodes": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { seriesId } = args;
+                const result = await clients.sonarr.renameEpisodes(seriesId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `All episodes for series ${seriesId} will be renamed`,
+                                commandId: result.id,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_get_releases": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { seriesId, page = 1, pageSize = 10 } = args;
+                const releases = await clients.sonarr.getReleases(seriesId, page, pageSize);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                totalRecords: releases.length,
+                                page,
+                                pageSize,
+                                releases: releases.map((r) => ({
+                                    guid: r.guid,
+                                    title: r.title,
+                                    indexer: r.indexer,
+                                    quality: r.quality,
+                                    size: formatBytes(r.size),
+                                    age: r.age,
+                                    ageHours: r.ageHours,
+                                    rejected: r.rejected,
+                                    rejectionReason: r.rejectionReason,
+                                    publishedDate: r.publishedDate,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_delete_release": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { guid } = args;
+                await clients.sonarr.deleteRelease(guid);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Release ${guid} deleted from history`,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_create_release_profile": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const profile = await clients.sonarr.createReleaseProfile(args);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Release profile '${profile.name}' created`,
+                                profileId: profile.id,
+                                profile,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_update_release_profile": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { profileId, ...updates } = args;
+                const profile = await clients.sonarr.updateReleaseProfile(profileId, updates);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Release profile ${profileId} updated`,
+                                profileId: profile.id,
+                                profile,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_delete_release_profile": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { profileId } = args;
+                await clients.sonarr.deleteReleaseProfile(profileId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Release profile ${profileId} deleted`,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_create_tag": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { label } = args;
+                const tag = await clients.sonarr.createTag(label);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Tag '${label}' created`,
+                                tagId: tag.id,
+                                tag,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_update_tag": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { tagId, label } = args;
+                const tag = await clients.sonarr.updateTag(tagId, label);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Tag ${tagId} updated to '${label}'`,
+                                tagId: tag.id,
+                                tag,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_delete_tag": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { tagId } = args;
+                await clients.sonarr.deleteTag(tagId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Tag ${tagId} deleted`,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_get_history": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { page = 1, pageSize = 20, seriesId } = args;
+                if (seriesId) {
+                    const history = await clients.sonarr.getSeriesHistory(seriesId);
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    seriesId,
+                                    count: history.length,
+                                    records: history.map((h) => ({
+                                        id: h.id,
+                                        date: h.date,
+                                        eventType: h.eventType,
+                                        sourceTitle: h.sourceTitle,
+                                        quality: h.quality?.quality?.name,
+                                        episodeId: h.episodeId,
+                                    })),
+                                }, null, 2),
+                            }],
+                    };
+                }
+                const history = await clients.sonarr.getHistory(page, pageSize);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                page,
+                                pageSize,
+                                totalRecords: history.totalRecords,
+                                records: history.records.map((h) => ({
+                                    id: h.id,
+                                    seriesId: h.seriesId,
+                                    episodeId: h.episodeId,
+                                    date: h.date,
+                                    eventType: h.eventType,
+                                    sourceTitle: h.sourceTitle,
+                                    quality: h.quality?.quality?.name,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_get_wanted": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { page = 1, pageSize = 20 } = args;
+                const wanted = await clients.sonarr.getWanted(page, pageSize);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                page,
+                                pageSize,
+                                totalRecords: wanted.totalRecords,
+                                episodes: wanted.records.map((e) => ({
+                                    id: e.id,
+                                    seriesId: e.seriesId,
+                                    seasonNumber: e.seasonNumber,
+                                    episodeNumber: e.episodeNumber,
+                                    title: e.title,
+                                    airDate: e.airDate,
+                                    monitored: e.monitored,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "sonarr_get_cutoff_unmet": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { page = 1, pageSize = 20 } = args;
+                const cutoff = await clients.sonarr.getCutoffUnmet(page, pageSize);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                page,
+                                pageSize,
+                                totalRecords: cutoff.totalRecords,
+                                episodes: cutoff.records.map((e) => ({
+                                    id: e.id,
+                                    seriesId: e.seriesId,
+                                    seasonNumber: e.seasonNumber,
+                                    episodeNumber: e.episodeNumber,
+                                    title: e.title,
+                                    currentQuality: e.episodeFile?.quality?.quality?.name,
                                 })),
                             }, null, 2),
                         }],
                 };
             }
-            // Naming config
-            case "sonarr_get_naming":
-            case "radarr_get_naming":
-            case "lidarr_get_naming":
-            case "readarr_get_naming": {
-                const serviceName = name.split('_')[0];
-                const client = clients[serviceName];
-                if (!client)
-                    throw new Error(`${serviceName} not configured`);
-                const naming = await client.getNamingConfig();
+            case "sonarr_get_blocklist": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { page = 1, pageSize = 20 } = args;
+                const blocklist = await clients.sonarr.getBlocklist(page, pageSize);
                 return {
                     content: [{
                             type: "text",
-                            text: JSON.stringify(naming, null, 2),
+                            text: JSON.stringify({
+                                page,
+                                pageSize,
+                                totalRecords: blocklist.totalRecords,
+                                records: blocklist.records.map((b) => ({
+                                    id: b.id,
+                                    seriesId: b.seriesId,
+                                    sourceTitle: b.sourceTitle,
+                                    date: b.date,
+                                    protocol: b.protocol,
+                                    indexer: b.indexer,
+                                    message: b.message,
+                                })),
+                            }, null, 2),
                         }],
                 };
             }
-            // Tags
-            case "sonarr_get_tags":
-            case "radarr_get_tags":
-            case "lidarr_get_tags":
-            case "readarr_get_tags": {
-                const serviceName = name.split('_')[0];
-                const client = clients[serviceName];
-                if (!client)
-                    throw new Error(`${serviceName} not configured`);
-                const tags = await client.getTags();
+            case "sonarr_delete_blocklist_item": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const { blocklistId } = args;
+                await clients.sonarr.deleteBlocklistItem(blocklistId);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
-                                count: tags.length,
-                                tags: tags.map((t) => ({ id: t.id, label: t.label })),
+                                success: true,
+                                message: `Blocklist item ${blocklistId} deleted`,
                             }, null, 2),
                         }],
                 };
             }
-            // Comprehensive setup review
-            case "sonarr_review_setup":
-            case "radarr_review_setup":
-            case "lidarr_review_setup":
-            case "readarr_review_setup": {
-                const serviceName = name.split('_')[0];
-                const client = clients[serviceName];
-                if (!client)
-                    throw new Error(`${serviceName} not configured`);
-                // Gather all configuration data
-                const [status, health, qualityProfiles, qualityDefinitions, downloadClients, naming, mediaManagement, rootFolders, tags, indexers] = await Promise.all([
-                    client.getStatus(),
-                    client.getHealth(),
-                    client.getQualityProfiles(),
-                    client.getQualityDefinitions(),
-                    client.getDownloadClients(),
-                    client.getNamingConfig(),
-                    client.getMediaManagement(),
-                    client.getRootFoldersDetailed(),
-                    client.getTags(),
-                    client.getIndexers(),
-                ]);
-                // For Lidarr/Readarr, also get metadata profiles
-                let metadataProfiles = null;
-                if (serviceName === 'lidarr' && clients.lidarr) {
-                    metadataProfiles = await clients.lidarr.getMetadataProfiles();
-                }
-                else if (serviceName === 'readarr' && clients.readarr) {
-                    metadataProfiles = await clients.readarr.getMetadataProfiles();
-                }
-                const review = {
-                    service: serviceName,
-                    version: status.version,
-                    appName: status.appName,
-                    platform: {
-                        os: status.osName,
-                        isDocker: status.isDocker,
-                    },
-                    health: {
-                        issueCount: health.length,
-                        issues: health,
-                    },
-                    storage: {
-                        rootFolders: rootFolders.map((f) => ({
-                            path: f.path,
-                            accessible: f.accessible,
-                            freeSpace: formatBytes(f.freeSpace),
-                            freeSpaceBytes: f.freeSpace,
-                            unmappedFolderCount: f.unmappedFolders?.length || 0,
-                        })),
-                    },
-                    qualityProfiles: qualityProfiles.map((p) => ({
-                        id: p.id,
-                        name: p.name,
-                        upgradeAllowed: p.upgradeAllowed,
-                        cutoff: p.cutoff,
-                        allowedQualities: p.items
-                            .filter((i) => i.allowed)
-                            .map((i) => i.quality?.name || i.name || (i.items?.map((q) => q.quality.name).join(', ')))
-                            .filter(Boolean),
-                        customFormatsWithScores: p.formatItems?.filter((f) => f.score !== 0).length || 0,
-                        minFormatScore: p.minFormatScore,
-                    })),
-                    qualityDefinitions: qualityDefinitions.map((d) => ({
-                        quality: d.quality.name,
-                        minSize: d.minSize + ' MB/min',
-                        maxSize: d.maxSize === 0 ? 'unlimited' : d.maxSize + ' MB/min',
-                        preferredSize: d.preferredSize + ' MB/min',
-                    })),
-                    downloadClients: downloadClients.map((c) => ({
-                        name: c.name,
-                        type: c.implementationName,
-                        protocol: c.protocol,
-                        enabled: c.enable,
-                        priority: c.priority,
-                    })),
-                    indexers: indexers.map((i) => ({
-                        name: i.name,
-                        protocol: i.protocol,
-                        enableRss: i.enableRss,
-                        enableAutomaticSearch: i.enableAutomaticSearch,
-                        enableInteractiveSearch: i.enableInteractiveSearch,
-                        priority: i.priority,
-                    })),
-                    naming: naming,
-                    mediaManagement: {
-                        recycleBin: mediaManagement.recycleBin || 'not set',
-                        recycleBinCleanupDays: mediaManagement.recycleBinCleanupDays,
-                        downloadPropersAndRepacks: mediaManagement.downloadPropersAndRepacks,
-                        deleteEmptyFolders: mediaManagement.deleteEmptyFolders,
-                        copyUsingHardlinks: mediaManagement.copyUsingHardlinks,
-                        importExtraFiles: mediaManagement.importExtraFiles,
-                        extraFileExtensions: mediaManagement.extraFileExtensions,
-                    },
-                    tags: tags.map((t) => t.label),
-                    ...(metadataProfiles && { metadataProfiles }),
-                };
+            case "sonarr_search_all_missing": {
+                if (!clients.sonarr)
+                    throw new Error("Sonarr not configured");
+                const result = await clients.sonarr.searchAllMissing();
                 return {
                     content: [{
                             type: "text",
-                            text: JSON.stringify(review, null, 2),
+                            text: JSON.stringify({
+                                success: true,
+                                message: 'Search triggered for all missing episodes',
+                                commandId: result.id,
+                            }, null, 2),
                         }],
                 };
             }
-            // Sonarr handlers
-            case "sonarr_get_series": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const series = await clients.sonarr.getSeries();
+            // Radarr handlers
+            case "radarr_get_movies": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const movies = await clients.radarr.getMovies();
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
-                                count: series.length,
-                                series: series.map(s => ({
-                                    id: s.id,
-                                    title: s.title,
-                                    year: s.year,
-                                    status: s.status,
-                                    network: s.network,
-                                    seasons: s.statistics?.seasonCount,
-                                    episodes: s.statistics?.episodeFileCount + '/' + s.statistics?.totalEpisodeCount,
-                                    sizeOnDisk: formatBytes(s.statistics?.sizeOnDisk || 0),
-                                    monitored: s.monitored,
+                                count: movies.length,
+                                movies: movies.map(m => ({
+                                    id: m.id,
+                                    title: m.title,
+                                    year: m.year,
+                                    status: m.status,
+                                    hasFile: m.hasFile,
+                                    sizeOnDisk: formatBytes(m.sizeOnDisk),
+                                    monitored: m.monitored,
+                                    studio: m.studio,
                                 })),
                             }, null, 2),
                         }],
                 };
             }
-            case "sonarr_search": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
+            case "radarr_search": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
                 const term = args.term;
-                const results = await clients.sonarr.searchSeries(term);
+                const results = await clients.radarr.searchMovies(term);
                 return {
                     content: [{
                             type: "text",
@@ -1377,17 +2637,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                 results: results.slice(0, 10).map(r => ({
                                     title: r.title,
                                     year: r.year,
-                                    tvdbId: r.tvdbId,
+                                    tmdbId: r.tmdbId,
+                                    imdbId: r.imdbId,
                                     overview: r.overview?.substring(0, 200) + (r.overview && r.overview.length > 200 ? '...' : ''),
                                 })),
                             }, null, 2),
                         }],
                 };
             }
-            case "sonarr_get_queue": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const queue = await clients.sonarr.getQueue();
+            case "radarr_get_queue": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const queue = await clients.radarr.getQueue();
                 return {
                     content: [{
                             type: "text",
@@ -1404,83 +2665,44 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         }],
                 };
             }
-            case "sonarr_get_calendar": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const days = args?.days || 7;
+            case "radarr_get_calendar": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const days = args?.days || 30;
                 const start = new Date().toISOString().split('T')[0];
                 const end = new Date(Date.now() + days * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
-                const calendar = await clients.sonarr.getCalendar(start, end);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(calendar, null, 2) }],
-                };
-            }
-            case "sonarr_get_episodes": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const { seriesId, seasonNumber } = args;
-                const episodes = await clients.sonarr.getEpisodes(seriesId, seasonNumber);
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                count: episodes.length,
-                                episodes: episodes.map(e => ({
-                                    id: e.id,
-                                    seasonNumber: e.seasonNumber,
-                                    episodeNumber: e.episodeNumber,
-                                    title: e.title,
-                                    airDate: e.airDate,
-                                    hasFile: e.hasFile,
-                                    monitored: e.monitored,
-                                })),
-                            }, null, 2),
-                        }],
-                };
-            }
-            case "sonarr_search_missing": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const seriesId = args.seriesId;
-                const result = await clients.sonarr.searchMissing(seriesId);
+                const calendar = await clients.radarr.getCalendar(start, end);
                 return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Search triggered for missing episodes`,
-                                commandId: result.id,
-                            }, null, 2),
-                        }],
+                    content: [{ type: "text", text: JSON.stringify(calendar, null, 2) }],
                 };
             }
-            case "sonarr_search_episode": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const episodeIds = args.episodeIds;
-                const result = await clients.sonarr.searchEpisode(episodeIds);
+            case "radarr_search_movie": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const movieId = args.movieId;
+                const result = await clients.radarr.searchMovie(movieId);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
                                 success: true,
-                                message: `Search triggered for ${episodeIds.length} episode(s)`,
+                                message: `Search triggered for movie`,
                                 commandId: result.id,
                             }, null, 2),
                         }],
                 };
             }
-            case "sonarr_add_series": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const { tvdbId, title, qualityProfileId, rootFolderPath, seasonFolder, monitored, tags } = args;
-                const series = await clients.sonarr.addSeries({
-                    tvdbId,
+            case "radarr_add_movie": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const { tmdbId, title, qualityProfileId, rootFolderPath, monitored, minimumAvailability, tags } = args;
+                const movie = await clients.radarr.addMovie({
+                    tmdbId,
                     title,
                     qualityProfileId,
                     rootFolderPath,
-                    seasonFolder,
                     monitored,
+                    minimumAvailability: minimumAvailability || 'released',
                     tags,
                 });
                 return {
@@ -1488,374 +2710,396 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             type: "text",
                             text: JSON.stringify({
                                 success: true,
-                                message: `Series '${title}' added to Sonarr`,
-                                seriesId: series.id,
-                                series: {
-                                    id: series.id,
-                                    title: series.title,
-                                    path: series.path,
-                                    monitored: series.monitored,
+                                message: `Movie '${movie.title}' added to Radarr`,
+                                movieId: movie.id,
+                                movie: {
+                                    id: movie.id,
+                                    title: movie.title,
+                                    path: movie.path,
+                                    monitored: movie.monitored,
                                 },
                             }, null, 2),
                         }],
                 };
             }
-            case "sonarr_update_series": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const { seriesId, ...updates } = args;
-                const series = await clients.sonarr.updateSeries(seriesId, updates);
+            case "radarr_update_movie": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const { movieId, ...updates } = args;
+                const movie = await clients.radarr.updateMovie(movieId, updates);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
                                 success: true,
-                                message: `Series '${series.title}' updated`,
-                                seriesId: series.id,
+                                message: `Movie '${movie.title}' updated`,
+                                movieId: movie.id,
                                 updates: Object.keys(updates),
                             }, null, 2),
                         }],
                 };
             }
-            case "sonarr_delete_series": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const { seriesId, deleteFiles = false, addImportListExclusion = false } = args;
-                await clients.sonarr.deleteSeries(seriesId, deleteFiles, addImportListExclusion);
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Series deleted (files: ${deleteFiles}, exclude: ${addImportListExclusion})`,
-                            }, null, 2),
-                        }],
-                };
-            }
-            case "sonarr_update_episode": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const { episodeId, monitored } = args;
-                const episode = await clients.sonarr.updateEpisode(episodeId, { monitored });
-                return {
-                    content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                success: true,
-                                message: `Episode ${episodeId} ${monitored ? 'monitored' : 'unmonitored'}`,
-                                episodeId: episode.id,
-                                monitored: episode.monitored,
-                            }, null, 2),
-                        }],
-                };
-            }
-            case "sonarr_delete_episode_file": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const { episodeFileId } = args;
-                await clients.sonarr.deleteEpisodeFile(episodeFileId);
+            case "radarr_delete_movie": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const { movieId, deleteFiles = false, addImportExclusion = false } = args;
+                await clients.radarr.deleteMovie(movieId, deleteFiles, addImportExclusion);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
                                 success: true,
-                                message: `Episode file ${episodeFileId} deleted`,
+                                message: `Movie deleted (files: ${deleteFiles}, exclude: ${addImportExclusion})`,
                             }, null, 2),
                         }],
                 };
             }
-            case "sonarr_refresh_series": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const { seriesId } = args;
-                const result = await clients.sonarr.refreshSeries(seriesId);
+            case "radarr_get_history": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const { page = 1, pageSize = 20, movieId } = args;
+                if (movieId) {
+                    const history = await clients.radarr.getMovieHistory(movieId);
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    movieId,
+                                    count: history.length,
+                                    records: history.map((h) => ({
+                                        id: h.id,
+                                        date: h.date,
+                                        eventType: h.eventType,
+                                        sourceTitle: h.sourceTitle,
+                                        quality: h.quality?.quality?.name,
+                                        downloadId: h.downloadId,
+                                    })),
+                                }, null, 2),
+                            }],
+                    };
+                }
+                const history = await clients.radarr.getHistory(page, pageSize);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
-                                success: true,
-                                message: `Series ${seriesId} metadata refresh triggered`,
-                                commandId: result.id,
+                                page,
+                                pageSize,
+                                totalRecords: history.totalRecords,
+                                records: history.records.map((h) => ({
+                                    id: h.id,
+                                    movieId: h.movieId,
+                                    date: h.date,
+                                    eventType: h.eventType,
+                                    sourceTitle: h.sourceTitle,
+                                    quality: h.quality?.quality?.name,
+                                })),
                             }, null, 2),
                         }],
                 };
             }
-            case "sonarr_rescan_series": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const { seriesId } = args;
-                const result = await clients.sonarr.rescanSeries(seriesId);
+            case "radarr_refresh_movie": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const { movieId } = args;
+                const result = await clients.radarr.refreshMovie(movieId);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
                                 success: true,
-                                message: `Series ${seriesId} disk rescan triggered`,
+                                message: `Movie ${movieId} metadata refresh triggered`,
                                 commandId: result.id,
                             }, null, 2),
                         }],
                 };
             }
-            case "sonarr_rename_series": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const { seriesId } = args;
-                const result = await clients.sonarr.renameSeries(seriesId);
+            case "radarr_rescan_movie": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const { movieId } = args;
+                const result = await clients.radarr.rescanMovie(movieId);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
                                 success: true,
-                                message: `Series ${seriesId} files will be renamed`,
+                                message: `Movie ${movieId} disk rescan triggered`,
                                 commandId: result.id,
                             }, null, 2),
                         }],
                 };
             }
-            case "sonarr_rename_episodes": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const { seriesId } = args;
-                const result = await clients.sonarr.renameEpisodes(seriesId);
+            case "radarr_rename_movie": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const { movieId } = args;
+                const result = await clients.radarr.renameMovie(movieId);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
                                 success: true,
-                                message: `All episodes for series ${seriesId} will be renamed`,
+                                message: `Movie ${movieId} files will be renamed`,
                                 commandId: result.id,
                             }, null, 2),
                         }],
                 };
             }
-            case "sonarr_get_releases": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const { seriesId, page = 1, pageSize = 10 } = args;
-                const releases = await clients.sonarr.getReleases(seriesId, page, pageSize);
+            case "radarr_get_collections": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const collections = await clients.radarr.getCollections();
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
-                                totalRecords: releases.length,
-                                page,
-                                pageSize,
-                                releases: releases.map((r) => ({
-                                    guid: r.guid,
-                                    title: r.title,
-                                    indexer: r.indexer,
-                                    quality: r.quality,
-                                    size: formatBytes(r.size),
-                                    age: r.age,
-                                    ageHours: r.ageHours,
-                                    rejected: r.rejected,
-                                    rejectionReason: r.rejectionReason,
-                                    publishedDate: r.publishedDate,
+                                count: collections.length,
+                                collections: collections.map((c) => ({
+                                    id: c.id,
+                                    title: c.title,
+                                    tmdbId: c.tmdbId,
+                                    monitored: c.monitored,
+                                    movieCount: c.movies?.length || 0,
+                                    qualityProfileId: c.qualityProfileId,
+                                    rootFolderPath: c.rootFolderPath,
                                 })),
                             }, null, 2),
                         }],
                 };
             }
-            case "sonarr_delete_release": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const { guid } = args;
-                await clients.sonarr.deleteRelease(guid);
+            case "radarr_update_collection": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const { collectionId, ...updates } = args;
+                const collection = await clients.radarr.updateCollection(collectionId, updates);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
                                 success: true,
-                                message: `Release ${guid} deleted from history`,
+                                message: `Collection '${collection.title}' updated`,
+                                collectionId: collection.id,
+                                updates: Object.keys(updates),
                             }, null, 2),
                         }],
                 };
             }
-            case "sonarr_create_release_profile": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const profile = await clients.sonarr.createReleaseProfile(args);
+            case "radarr_get_movie_files": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const { movieId } = args;
+                const files = await clients.radarr.getMovieFiles(movieId);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
-                                success: true,
-                                message: `Release profile '${profile.name}' created`,
-                                profileId: profile.id,
-                                profile,
+                                movieId,
+                                count: files.length,
+                                files: files.map((f) => ({
+                                    id: f.id,
+                                    relativePath: f.relativePath,
+                                    size: formatBytes(f.size),
+                                    quality: f.quality?.quality?.name,
+                                    dateAdded: f.dateAdded,
+                                    mediaInfo: f.mediaInfo ? {
+                                        resolution: f.mediaInfo.resolution,
+                                        videoCodec: f.mediaInfo.videoCodec,
+                                        audioCodec: f.mediaInfo.audioCodec,
+                                        audioChannels: f.mediaInfo.audioChannels,
+                                        runTime: f.mediaInfo.runTime,
+                                    } : null,
+                                })),
                             }, null, 2),
                         }],
                 };
             }
-            case "sonarr_update_release_profile": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const { profileId, ...updates } = args;
-                const profile = await clients.sonarr.updateReleaseProfile(profileId, updates);
+            case "radarr_delete_movie_file": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const { movieFileId } = args;
+                await clients.radarr.deleteMovieFile(movieFileId);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
                                 success: true,
-                                message: `Release profile ${profileId} updated`,
-                                profileId: profile.id,
-                                profile,
+                                message: `Movie file ${movieFileId} deleted`,
                             }, null, 2),
                         }],
                 };
             }
-            case "sonarr_delete_release_profile": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const { profileId } = args;
-                await clients.sonarr.deleteReleaseProfile(profileId);
+            case "radarr_get_blocklist": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const { page = 1, pageSize = 20 } = args;
+                const blocklist = await clients.radarr.getBlocklist(page, pageSize);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
-                                success: true,
-                                message: `Release profile ${profileId} deleted`,
+                                page,
+                                pageSize,
+                                totalRecords: blocklist.totalRecords,
+                                records: blocklist.records.map((b) => ({
+                                    id: b.id,
+                                    movieId: b.movieId,
+                                    sourceTitle: b.sourceTitle,
+                                    date: b.date,
+                                    protocol: b.protocol,
+                                    indexer: b.indexer,
+                                    message: b.message,
+                                })),
                             }, null, 2),
                         }],
                 };
             }
-            case "sonarr_create_tag": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const { label } = args;
-                const tag = await clients.sonarr.createTag(label);
+            case "radarr_delete_blocklist_item": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const { blocklistId } = args;
+                await clients.radarr.deleteBlocklistItem(blocklistId);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
                                 success: true,
-                                message: `Tag '${label}' created`,
-                                tagId: tag.id,
-                                tag,
+                                message: `Blocklist item ${blocklistId} deleted`,
                             }, null, 2),
                         }],
                 };
             }
-            case "sonarr_update_tag": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const { tagId, label } = args;
-                const tag = await clients.sonarr.updateTag(tagId, label);
+            case "radarr_get_extra_files": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const { movieId } = args;
+                const files = await clients.radarr.getExtraFiles(movieId);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
-                                success: true,
-                                message: `Tag ${tagId} updated to '${label}'`,
-                                tagId: tag.id,
-                                tag,
+                                movieId,
+                                count: files.length,
+                                files: files.map((f) => ({
+                                    id: f.id,
+                                    relativePath: f.relativePath,
+                                    extension: f.extension,
+                                    type: f.type,
+                                })),
                             }, null, 2),
                         }],
                 };
             }
-            case "sonarr_delete_tag": {
-                if (!clients.sonarr)
-                    throw new Error("Sonarr not configured");
-                const { tagId } = args;
-                await clients.sonarr.deleteTag(tagId);
+            case "radarr_get_credits": {
+                if (!clients.radarr)
+                    throw new Error("Radarr not configured");
+                const { movieId } = args;
+                const credits = await clients.radarr.getCredits(movieId);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
-                                success: true,
-                                message: `Tag ${tagId} deleted`,
+                                movieId,
+                                count: credits.length,
+                                cast: credits.filter((c) => c.type === 'cast').slice(0, 20).map((c) => ({
+                                    name: c.personName,
+                                    character: c.character,
+                                    order: c.order,
+                                })),
+                                crew: credits.filter((c) => c.type === 'crew').slice(0, 10).map((c) => ({
+                                    name: c.personName,
+                                    job: c.job,
+                                    department: c.department,
+                                })),
                             }, null, 2),
                         }],
                 };
             }
-            // Radarr handlers
-            case "radarr_get_movies": {
+            case "radarr_get_wanted": {
                 if (!clients.radarr)
                     throw new Error("Radarr not configured");
-                const movies = await clients.radarr.getMovies();
+                const { page = 1, pageSize = 20 } = args;
+                const wanted = await clients.radarr.getWanted(page, pageSize);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
-                                count: movies.length,
-                                movies: movies.map(m => ({
+                                page,
+                                pageSize,
+                                totalRecords: wanted.totalRecords,
+                                movies: wanted.records.map((m) => ({
                                     id: m.id,
                                     title: m.title,
                                     year: m.year,
                                     status: m.status,
-                                    hasFile: m.hasFile,
-                                    sizeOnDisk: formatBytes(m.sizeOnDisk),
                                     monitored: m.monitored,
-                                    studio: m.studio,
+                                    isAvailable: m.isAvailable,
+                                    minimumAvailability: m.minimumAvailability,
                                 })),
                             }, null, 2),
                         }],
                 };
             }
-            case "radarr_search": {
+            case "radarr_search_missing": {
                 if (!clients.radarr)
                     throw new Error("Radarr not configured");
-                const term = args.term;
-                const results = await clients.radarr.searchMovies(term);
+                const result = await clients.radarr.searchMissing();
                 return {
                     content: [{
-                            type: "text",
-                            text: JSON.stringify({
-                                count: results.length,
-                                results: results.slice(0, 10).map(r => ({
-                                    title: r.title,
-                                    year: r.year,
-                                    tmdbId: r.tmdbId,
-                                    imdbId: r.imdbId,
-                                    overview: r.overview?.substring(0, 200) + (r.overview && r.overview.length > 200 ? '...' : ''),
-                                })),
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: 'Search triggered for all missing movies',
+                                commandId: result.id,
                             }, null, 2),
                         }],
                 };
             }
-            case "radarr_get_queue": {
+            case "radarr_create_tag": {
                 if (!clients.radarr)
                     throw new Error("Radarr not configured");
-                const queue = await clients.radarr.getQueue();
+                const { label } = args;
+                const tag = await clients.radarr.createTag(label);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
-                                totalRecords: queue.totalRecords,
-                                items: queue.records.map(q => ({
-                                    title: q.title,
-                                    status: q.status,
-                                    progress: ((1 - q.sizeleft / q.size) * 100).toFixed(1) + '%',
-                                    timeLeft: q.timeleft,
-                                    downloadClient: q.downloadClient,
-                                })),
+                                success: true,
+                                message: `Tag '${label}' created`,
+                                tagId: tag.id,
+                                tag,
                             }, null, 2),
                         }],
                 };
             }
-            case "radarr_get_calendar": {
+            case "radarr_update_tag": {
                 if (!clients.radarr)
                     throw new Error("Radarr not configured");
-                const days = args?.days || 30;
-                const start = new Date().toISOString().split('T')[0];
-                const end = new Date(Date.now() + days * 24 * 60 * 60 * 1000).toISOString().split('T')[0];
-                const calendar = await clients.radarr.getCalendar(start, end);
+                const { tagId, label } = args;
+                const tag = await clients.radarr.updateTag(tagId, label);
                 return {
-                    content: [{ type: "text", text: JSON.stringify(calendar, null, 2) }],
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Tag ${tagId} updated to '${label}'`,
+                                tagId: tag.id,
+                                tag,
+                            }, null, 2),
+                        }],
                 };
             }
-            case "radarr_search_movie": {
+            case "radarr_delete_tag": {
                 if (!clients.radarr)
                     throw new Error("Radarr not configured");
-                const movieId = args.movieId;
-                const result = await clients.radarr.searchMovie(movieId);
+                const { tagId } = args;
+                await clients.radarr.deleteTag(tagId);
                 return {
                     content: [{
                             type: "text",
                             text: JSON.stringify({
                                 success: true,
-                                message: `Search triggered for movie`,
-                                commandId: result.id,
+                                message: `Tag ${tagId} deleted`,
                             }, null, 2),
                         }],
                 };
@@ -2147,7 +3391,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             case "prowlarr_get_indexers": {
                 if (!clients.prowlarr)
                     throw new Error("Prowlarr not configured");
-                const indexers = await clients.prowlarr.getIndexers();
+                const indexers = await clients.prowlarr.getProwlarrIndexers();
                 return {
                     content: [{
                             type: "text",
@@ -2157,9 +3401,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                     id: i.id,
                                     name: i.name,
                                     protocol: i.protocol,
-                                    enableRss: i.enableRss,
-                                    enableAutomaticSearch: i.enableAutomaticSearch,
-                                    enableInteractiveSearch: i.enableInteractiveSearch,
+                                    enable: i.enable,
+                                    supportsRss: i.supportsRss,
+                                    supportsSearch: i.supportsSearch,
                                     priority: i.priority,
                                 })),
                             }, null, 2),
@@ -2179,7 +3423,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 if (!clients.prowlarr)
                     throw new Error("Prowlarr not configured");
                 const results = await clients.prowlarr.testAllIndexers();
-                const indexers = await clients.prowlarr.getIndexers();
+                const indexers = await clients.prowlarr.getProwlarrIndexers();
                 const indexerMap = new Map(indexers.map(i => [i.id, i.name]));
                 return {
                     content: [{
@@ -2225,6 +3469,350 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         }],
                 };
             }
+            case "prowlarr_get_indexer": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { indexerId } = args;
+                const indexer = await clients.prowlarr.getIndexerById(indexerId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(indexer, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_update_indexer": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { indexerId, enable, priority, tags } = args;
+                const updates = {};
+                if (enable !== undefined)
+                    updates.enable = enable;
+                if (priority !== undefined)
+                    updates.priority = priority;
+                if (tags !== undefined)
+                    updates.tags = tags;
+                const updated = await clients.prowlarr.updateIndexer(indexerId, updates);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                indexer: {
+                                    id: updated.id,
+                                    name: updated.name,
+                                    enable: updated.enable,
+                                    priority: updated.priority,
+                                    tags: updated.tags,
+                                },
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_delete_indexer": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { indexerId } = args;
+                await clients.prowlarr.deleteIndexer(indexerId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ success: true, message: `Indexer ${indexerId} deleted` }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_test_indexer": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { indexerId } = args;
+                const result = await clients.prowlarr.testIndexer(indexerId);
+                const indexer = await clients.prowlarr.getIndexerById(indexerId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                id: indexerId,
+                                name: indexer.name,
+                                isValid: result.isValid,
+                                errors: result.validationFailures.map(f => f.errorMessage),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_get_applications": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const apps = await clients.prowlarr.getApplications();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                count: apps.length,
+                                applications: apps.map(a => ({
+                                    id: a.id,
+                                    name: a.name,
+                                    implementation: a.implementation,
+                                    syncLevel: a.syncLevel,
+                                    tags: a.tags,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_get_application": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { applicationId } = args;
+                const app = await clients.prowlarr.getApplicationById(applicationId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify(app, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_update_application": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { applicationId, syncLevel, tags } = args;
+                const updates = {};
+                if (syncLevel !== undefined)
+                    updates.syncLevel = syncLevel;
+                if (tags !== undefined)
+                    updates.tags = tags;
+                const updated = await clients.prowlarr.updateApplication(applicationId, updates);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                application: {
+                                    id: updated.id,
+                                    name: updated.name,
+                                    syncLevel: updated.syncLevel,
+                                    tags: updated.tags,
+                                },
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_delete_application": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { applicationId } = args;
+                await clients.prowlarr.deleteApplication(applicationId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ success: true, message: `Application ${applicationId} deleted` }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_test_application": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { applicationId } = args;
+                const result = await clients.prowlarr.testApplication(applicationId);
+                const app = await clients.prowlarr.getApplicationById(applicationId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                id: applicationId,
+                                name: app.name,
+                                isValid: result.isValid,
+                                errors: result.validationFailures.map(f => f.errorMessage),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_sync_applications": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const result = await clients.prowlarr.syncApplications();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: "Application indexer sync triggered",
+                                commandId: result.id,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_get_app_profiles": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const profiles = await clients.prowlarr.getAppProfiles();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                count: profiles.length,
+                                profiles: profiles.map(p => ({
+                                    id: p.id,
+                                    name: p.name,
+                                    enableRss: p.enableRss,
+                                    enableAutomaticSearch: p.enableAutomaticSearch,
+                                    enableInteractiveSearch: p.enableInteractiveSearch,
+                                    minimumSeeders: p.minimumSeeders,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_get_history": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { page, pageSize, indexerId } = args;
+                let history;
+                if (indexerId) {
+                    const records = await clients.prowlarr.getIndexerHistory(indexerId);
+                    history = { records, totalRecords: records.length };
+                }
+                else {
+                    history = await clients.prowlarr.getHistory(page || 1, pageSize || 20);
+                }
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                totalRecords: history.totalRecords,
+                                records: history.records.map((r) => ({
+                                    id: r.id,
+                                    indexerId: r.indexerId,
+                                    eventType: r.eventType,
+                                    successful: r.successful,
+                                    date: r.date,
+                                    query: r.data?.query,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_get_tags": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const tags = await clients.prowlarr.getTags();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ count: tags.length, tags }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_create_tag": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { label } = args;
+                const tag = await clients.prowlarr.createTag(label);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ success: true, tag }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_update_tag": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { tagId, label } = args;
+                const tag = await clients.prowlarr.updateTag(tagId, label);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ success: true, tag }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_delete_tag": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const { tagId } = args;
+                await clients.prowlarr.deleteTag(tagId);
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({ success: true, message: `Tag ${tagId} deleted` }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_get_indexer_schemas": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const schemas = await clients.prowlarr.getIndexerSchemas();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                count: schemas.length,
+                                schemas: schemas.map(s => ({
+                                    implementation: s.implementation,
+                                    name: s.name,
+                                    protocol: s.protocol,
+                                    privacy: s.privacy,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_get_notifications": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const notifications = await clients.prowlarr.getNotifications();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                count: notifications.length,
+                                notifications: notifications.map(n => ({
+                                    id: n.id,
+                                    name: n.name,
+                                    implementation: n.implementation,
+                                    onHealthIssue: n.onHealthIssue,
+                                    onApplicationUpdate: n.onApplicationUpdate,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_rss_sync": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const result = await clients.prowlarr.rssSync();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                message: "RSS sync triggered for all indexers",
+                                commandId: result.id,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "prowlarr_get_download_clients": {
+                if (!clients.prowlarr)
+                    throw new Error("Prowlarr not configured");
+                const downloadClients = await clients.prowlarr.getDownloadClients();
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                count: downloadClients.length,
+                                clients: downloadClients.map(c => ({
+                                    id: c.id,
+                                    name: c.name,
+                                    implementation: c.implementation,
+                                    protocol: c.protocol,
+                                    enable: c.enable,
+                                    priority: c.priority,
+                                })),
+                            }, null, 2),
+                        }],
+                };
+            }
             // Cross-service search
             case "arr_search_all": {
                 const term = args.term;