MediaWiki API MCP Server

"""MediaWiki page parsing handlers for MCP server.""" import logging from collections.abc import Sequence from typing import Any import mcp.types as types from ..client import MediaWikiClient logger = logging.getLogger(__name__) async def handle_parse_page( client: MediaWikiClient, arguments: dict[str, Any] ) -> Sequence[types.TextContent]: """Handle wiki_page_parse tool calls with comprehensive Parse API support.""" # Extract arguments with defaults title = arguments.get("title") pageid = arguments.get("pageid") oldid = arguments.get("oldid") text = arguments.get("text") revid = arguments.get("revid") summary = arguments.get("summary") page = arguments.get("page") redirects = arguments.get("redirects", False) prop = arguments.get("prop") wrapoutputclass = arguments.get("wrapoutputclass") usearticle = arguments.get("usearticle", False) parsoid = arguments.get("parsoid", False) pst = arguments.get("pst", False) onlypst = arguments.get("onlypst", False) section = arguments.get("section") sectiontitle = arguments.get("sectiontitle") disablelimitreport = arguments.get("disablelimitreport", False) disableeditsection = arguments.get("disableeditsection", False) disablestylededuplication = arguments.get("disablestylededuplication", False) showstrategykeys = arguments.get("showstrategykeys", False) preview = arguments.get("preview", False) sectionpreview = arguments.get("sectionpreview", False) disabletoc = arguments.get("disabletoc", False) useskin = arguments.get("useskin") contentformat = arguments.get("contentformat") contentmodel = arguments.get("contentmodel") mobileformat = arguments.get("mobileformat", False) templatesandboxprefix = arguments.get("templatesandboxprefix") templatesandboxtitle = arguments.get("templatesandboxtitle") templatesandboxtext = arguments.get("templatesandboxtext") templatesandboxcontentmodel = arguments.get("templatesandboxcontentmodel") templatesandboxcontentformat = arguments.get("templatesandboxcontentformat") # Validate that at least one content source is provided content_sources = [title, pageid, oldid, text, page, summary] if not any(content_sources): return [types.TextContent( type="text", text="Error: Must provide one of: title, pageid, oldid, text, page, or summary" )] # Special handling for summary-only parsing if summary and not any([title, pageid, oldid, text, page]): # Summary-only parsing requires empty prop parameter according to API docs if prop is None: prop = [] logger.debug(f"Summary-only parsing requested: {summary}") # Convert prop to list if it's a string if prop and isinstance(prop, str): prop = [p.strip() for p in prop.split("|") if p.strip()] # Convert templatesandboxprefix to list if it's a string if templatesandboxprefix and isinstance(templatesandboxprefix, str): templatesandboxprefix = [p.strip() for p in templatesandboxprefix.split("|") if p.strip()] # Convert title parameter to page parameter for consistency with MediaWiki API # The Parse API primarily uses 'page' parameter, not 'title' if title and not page: page = title title = None try: # Track if this is a summary-only parsing request for fallback handling is_summary_only = summary and not any([title, pageid, oldid, text, page]) result = await client.parse_page( title=title, pageid=pageid, oldid=oldid, text=text, revid=revid, summary=summary, page=page, redirects=redirects, prop=prop, wrapoutputclass=wrapoutputclass, usearticle=usearticle, parsoid=parsoid, pst=pst, onlypst=onlypst, section=section, sectiontitle=sectiontitle, disablelimitreport=disablelimitreport, disableeditsection=disableeditsection, disablestylededuplication=disablestylededuplication, showstrategykeys=showstrategykeys, preview=preview, sectionpreview=sectionpreview, disabletoc=disabletoc, useskin=useskin, contentformat=contentformat, contentmodel=contentmodel, mobileformat=mobileformat, templatesandboxprefix=templatesandboxprefix, templatesandboxtitle=templatesandboxtitle, templatesandboxtext=templatesandboxtext, templatesandboxcontentmodel=templatesandboxcontentmodel, templatesandboxcontentformat=templatesandboxcontentformat ) # If this was a summary-only parsing request and we got minimal content, # try a fallback approach by parsing the summary as regular text if is_summary_only and "parse" in result: parse_data = result["parse"] if "text" in parse_data: text_content = parse_data["text"] if isinstance(text_content, dict) and "*" in text_content: text_content = text_content["*"] # Check for minimal content (empty or very minimal parser output) if _is_minimal_content(text_content): logger.warning(f"Summary parsing returned minimal content, attempting fallback for: {summary}") # Try parsing the summary as regular text instead try: fallback_result = await client.parse_page( text=summary, contentmodel="wikitext", prop=["text", "categories", "links", "templates", "parsewarnings"], disablelimitreport=disablelimitreport, disableeditsection=disableeditsection ) if "parse" in fallback_result: fallback_parse = fallback_result["parse"] if "text" in fallback_parse: fallback_text = fallback_parse["text"] if isinstance(fallback_text, dict) and "*" in fallback_text: fallback_text = fallback_text["*"] # If fallback has better content, use it with a note if not _is_minimal_content(fallback_text): logger.info("Fallback summary parsing succeeded, using text parsing approach") # Update the result with fallback data but preserve original structure parse_data["text"] = fallback_parse["text"] # Add other useful properties from fallback if available for prop_name in ["categories", "links", "templates", "parsewarnings"]: if prop_name in fallback_parse: parse_data[prop_name] = fallback_parse[prop_name] # Add a note about the fallback if "parsewarnings" not in parse_data: parse_data["parsewarnings"] = [] parse_data["parsewarnings"].append("Note: Used text parsing fallback due to summary parsing issue") except Exception as fallback_error: logger.warning(f"Fallback summary parsing also failed: {fallback_error}") # Continue with original result # Handle API errors if "error" in result: error_info = result["error"] if isinstance(error_info, dict): error_code = error_info.get("code", "unknown") error_message = error_info.get("info", "Unknown error") return [types.TextContent( type="text", text=f"MediaWiki API Error ({error_code}): {error_message}" )] else: # Handle case where error is a string return [types.TextContent( type="text", text=f"MediaWiki API Error: {error_info}" )] # Handle warnings warning_text = None if "warnings" in result: warnings = result["warnings"] warning_messages = [] for key, warning in warnings.items(): if isinstance(warning, dict) and "*" in warning: warning_messages.append(f"{key}: {warning['*']}") else: warning_messages.append(f"{key}: {warning}") if warning_messages: warning_text = "API Warnings:\n" + "\n".join(warning_messages) if "parse" not in result: # Enhanced error reporting for debugging response_keys = list(result.keys()) # Create detailed error message based on response content error_details = [] error_details.append(f"Response keys: {response_keys}") # Check for common error patterns and provide specific guidance if "query" in result: error_details.append("Note: Received 'query' response - this indicates the wrong API endpoint was used") error_details.append("The Parse API should return a 'parse' key, not 'query'") # Check for missing pages in query response if isinstance(result.get("query", {}).get("pages", {}), dict): pages = result["query"]["pages"] missing_pages = [page for page in pages.values() if page.get("missing", False)] if missing_pages: error_details.append(f"Note: {len(missing_pages)} page(s) marked as missing in query response") elif "missing" in result: error_details.append("Note: Page is marked as missing in the response") elif "badtitle" in str(result).lower(): error_details.append("Note: Response suggests the page title may be invalid") elif any(key in result for key in ["nosuchsection", "invalidsection"]): error_details.append("Note: The specified section does not exist or is invalid") elif "invalidparammix" in str(result).lower(): error_details.append("Note: Invalid parameter combination detected") error_details.append("Check that conflicting parameters (page/title/text/oldid) are not used together") # Add parameter information for debugging used_params = [] for param in ["title", "pageid", "oldid", "text", "page", "summary"]: value = arguments.get(param) if value: used_params.append(f"{param}={repr(value)}") if used_params: error_details.append(f"Used parameters: {', '.join(used_params)}") # Add full response for debugging in case of unknown errors if len(str(result)) < 500: # Only include full response if it's not too long error_details.append(f"Full response: {result}") error_message = "Error: Unexpected response format from Parse API.\n" + "\n".join(error_details) return [types.TextContent( type="text", text=error_message )] return await _format_parse_result(result, prop, warning_text) except Exception as e: return [types.TextContent( type="text", text=f"Error parsing content: {str(e)}" )] async def _format_parse_result( result: dict[str, Any], requested_prop: list[str] | None, warning_text: str | None = None ) -> Sequence[types.TextContent]: """Format the parse result into a readable response.""" parse_data = result["parse"] # Build the response header title = parse_data.get("title", "Unknown") pageid = parse_data.get("pageid", "Unknown") revid = parse_data.get("revid", "Unknown") response_lines = [ f"Parse Results for: {title}", f"Page ID: {pageid}", f"Revision ID: {revid}", "" ] # Show warnings if any if warning_text: response_lines.append(warning_text) response_lines.append("") # Show which properties were requested if requested_prop: response_lines.append(f"Requested properties: {', '.join(requested_prop)}") response_lines.append("") # Format each available property formatted_sections = [] # Main content (text) if "text" in parse_data: text_content = parse_data["text"] if isinstance(text_content, dict) and "*" in text_content: text_content = text_content["*"] # Check for minimal content issue mentioned in bug report if text_content and len(text_content.strip()) > 0: # Check if it's just an empty div (common issue) or if fallback was used is_minimal = _is_minimal_content(text_content) if is_minimal: # This looks like minimal content - add warning formatted_sections.append(_format_section("Parsed HTML", f"WARNING: Content appears minimal. This may indicate a summary parsing issue.\n\n{text_content}")) else: formatted_sections.append(_format_section("Parsed HTML", text_content)) else: formatted_sections.append(_format_section("Parsed HTML", "WARNING: No HTML content returned. The page may be empty or there may be a parsing issue.")) else: # Check if this was an existing page request but no text was returned if any(parse_data.get(key) for key in ["pageid", "title"]) and parse_data.get("pageid", 0) > 0: formatted_sections.append(_format_section("Parsed HTML", "WARNING: No text content in parse result for existing page. This may indicate the page is empty or a parsing error occurred.")) # Wikitext if "wikitext" in parse_data: wikitext_content = parse_data["wikitext"] if isinstance(wikitext_content, dict) and "*" in wikitext_content: wikitext_content = wikitext_content["*"] formatted_sections.append(_format_section("Wikitext", wikitext_content)) # Categories if "categories" in parse_data: categories = parse_data["categories"] if categories: cat_list = [cat.get("*", cat.get("category", str(cat))) for cat in categories] formatted_sections.append(_format_section("Categories", "\n".join(cat_list))) # Links if "links" in parse_data: links = parse_data["links"] if links: link_list = [link.get("*", link.get("title", str(link))) for link in links] formatted_sections.append(_format_section("Internal Links", "\n".join(link_list))) # Templates if "templates" in parse_data: templates = parse_data["templates"] if templates: template_list = [tmpl.get("*", tmpl.get("title", str(tmpl))) for tmpl in templates] formatted_sections.append(_format_section("Templates", "\n".join(template_list))) # Images if "images" in parse_data: images = parse_data["images"] if images: image_list = [img if isinstance(img, str) else str(img) for img in images] formatted_sections.append(_format_section("Images", "\n".join(image_list))) # External links if "externallinks" in parse_data: external_links = parse_data["externallinks"] if external_links: link_list = [link if isinstance(link, str) else str(link) for link in external_links] formatted_sections.append(_format_section("External Links", "\n".join(link_list))) # Sections if "sections" in parse_data: sections = parse_data["sections"] if sections: section_list = [] for section in sections: level = section.get("level", "") line = section.get("line", "") section_list.append(f"Level {level}: {line}") formatted_sections.append(_format_section("Sections", "\n".join(section_list))) # Language links if "langlinks" in parse_data: langlinks = parse_data["langlinks"] if langlinks: lang_list = [] for link in langlinks: lang = link.get("lang", "") title = link.get("*", link.get("title", "")) lang_list.append(f"{lang}: {title}") formatted_sections.append(_format_section("Language Links", "\n".join(lang_list))) # Interwiki links if "iwlinks" in parse_data: iwlinks = parse_data["iwlinks"] if iwlinks: iw_list = [] for link in iwlinks: prefix = link.get("prefix", "") title = link.get("*", link.get("title", "")) iw_list.append(f"{prefix}: {title}") formatted_sections.append(_format_section("Interwiki Links", "\n".join(iw_list))) # Properties if "properties" in parse_data: properties = parse_data["properties"] if properties: prop_list = [] for prop in properties: name = prop.get("name", "") value = prop.get("*", prop.get("value", "")) prop_list.append(f"{name}: {value}") formatted_sections.append(_format_section("Properties", "\n".join(prop_list))) # Parse warnings if "parsewarnings" in parse_data: warnings = parse_data["parsewarnings"] if warnings: warning_list = [warning if isinstance(warning, str) else str(warning) for warning in warnings] formatted_sections.append(_format_section("Parse Warnings", "\n".join(warning_list))) # Display title if "displaytitle" in parse_data: display_title = parse_data["displaytitle"] formatted_sections.append(_format_section("Display Title", display_title)) # Combine all sections if formatted_sections: response_lines.extend(formatted_sections) else: response_lines.append("No content available in the parsed output.") return [types.TextContent( type="text", text="\n".join(response_lines) )] def _is_minimal_content(content: str) -> bool: """ Check if content appears to be minimal/empty, indicating a parsing issue. This detects cases where the MediaWiki API returns nearly empty content, which often indicates that the summary parsing didn't work properly. """ if not content or len(content.strip()) == 0: return True # Check for common minimal content patterns content_lower = content.lower().strip() # Empty parser wrapper divs with minimal content if ('<div class="mw-' in content_lower and content_lower.count('<') <= 3 and len(content.strip()) < 200): return True # Just whitespace or basic HTML structure if content_lower in ['<p></p>', '<div></div>', ''] or content_lower.isspace(): return True # Check for content that's basically just a parser wrapper with no actual content # Remove common wrapper patterns and see if there's actual content left import re # Remove parser wrapper divs cleaned = re.sub(r'<div[^>]*class="[^"]*mw-[^"]*"[^>]*>', '', content) cleaned = re.sub(r'</div>', '', cleaned) # Remove empty paragraphs and whitespace cleaned = re.sub(r'<p[^>]*></p>', '', cleaned) cleaned = re.sub(r'\s+', ' ', cleaned).strip() # If after removing wrappers there's very little content, it's likely minimal return len(cleaned) < 10 def _format_section(title: str, content: str) -> str: """Format a section with a title and content.""" if not content: return f"## {title}\n(No content)\n" # Truncate very long content for readability if len(content) > 5000: content = content[:5000] + "\n... (content truncated)" return f"## {title}\n{content}\n"