google-workspace-mcp 1.0.5__py3-none-any.whl → 1.1.5__py3-none-any.whl

google_workspace_mcp/tools/slides.py

@@ -14,10 +14,9 @@ logger = logging.getLogger(__name__)
 # --- Slides Tool Functions --- #
 
 
-@mcp.tool(
-    name="get_presentation",
-    description="Get a presentation by ID with its metadata and content.",
-)
+# @mcp.tool(
+#     name="get_presentation",
+# )
 async def get_presentation(presentation_id: str) -> dict[str, Any]:
     """
     Get presentation information including all slides and content.
@@ -42,10 +41,10 @@ async def get_presentation(presentation_id: str) -> dict[str, Any]:
     return result
 
 
-@mcp.tool(
-    name="get_slides",
-    description="Retrieves all slides from a presentation with their elements and notes.",
-)
+# @mcp.tool(
+#     name="get_slides",
+#     description="Retrieves all slides from a presentation with their elements and notes.",
+# )
 async def get_slides(presentation_id: str) -> dict[str, Any]:
     """
     Retrieves all slides from a presentation.
@@ -75,21 +74,24 @@ async def get_slides(presentation_id: str) -> dict[str, Any]:
 
 @mcp.tool(
     name="create_presentation",
-    description="Creates a new Google Slides presentation with the specified title.",
 )
 async def create_presentation(
     title: str,
+    delete_default_slide: bool = False,
 ) -> dict[str, Any]:
     """
     Create a new presentation.
 
     Args:
         title: The title for the new presentation.
+        delete_default_slide: If True, deletes the default slide created by Google Slides API.
 
     Returns:
         Created presentation data or raises error.
     """
-    logger.info(f"Executing create_presentation with title: '{title}'")
+    logger.info(
+        f"Executing create_presentation with title: '{title}', delete_default_slide: {delete_default_slide}"
+    )
     if not title or not title.strip():
         raise ValueError("Presentation title cannot be empty")
 
@@ -99,16 +101,53 @@ async def create_presentation(
     if isinstance(result, dict) and result.get("error"):
         raise ValueError(result.get("message", "Error creating presentation"))
 
-    return result
-
-
-@mcp.tool(
-    name="create_slide",
-    description="Adds a new slide to a Google Slides presentation with a specified layout.",
-)
+    # Extract essential information
+    presentation_id = result.get("presentationId")
+    if not presentation_id:
+        raise ValueError("Failed to get presentation ID from creation result")
+
+    # Prepare clean response
+    clean_result = {
+        "presentationId": presentation_id,
+        "title": title,
+        "status": "created_successfully",
+    }
+
+    # If requested, delete the default slide
+    if delete_default_slide and presentation_id:
+        # Get the first slide ID and delete it
+        presentation_data = slides_service.get_presentation(
+            presentation_id=presentation_id
+        )
+        if presentation_data.get("slides") and len(presentation_data["slides"]) > 0:
+            first_slide_id = presentation_data["slides"][0]["objectId"]
+            delete_result = slides_service.delete_slide(
+                presentation_id=presentation_id, slide_id=first_slide_id
+            )
+            if isinstance(delete_result, dict) and delete_result.get("error"):
+                logger.warning(
+                    f"Failed to delete default slide: {delete_result.get('message')}"
+                )
+                clean_result["default_slide_deleted"] = False
+                clean_result["delete_error"] = delete_result.get("message")
+            else:
+                logger.info("Successfully deleted default slide")
+                clean_result["default_slide_deleted"] = True
+                clean_result["status"] = "created_successfully_no_default_slide"
+        else:
+            clean_result["default_slide_deleted"] = False
+            clean_result["delete_error"] = "No slides found to delete"
+
+    return clean_result
+
+
+# @mcp.tool(
+#     name="create_slide",
+#     description="Adds a new slide to a Google Slides presentation with a specified layout.",
+# )
 async def create_slide(
     presentation_id: str,
-    layout: str = "TITLE_AND_BODY",
+    layout: str = "BLANK",
 ) -> dict[str, Any]:
     """
     Add a new slide to a presentation.
@@ -120,7 +159,9 @@ async def create_slide(
     Returns:
         Response data confirming slide creation or raises error.
     """
-    logger.info(f"Executing create_slide in presentation '{presentation_id}' with layout '{layout}'")
+    logger.info(
+        f"Executing create_slide in presentation '{presentation_id}' with layout '{layout}'"
+    )
     if not presentation_id or not presentation_id.strip():
         raise ValueError("Presentation ID cannot be empty")
     # Optional: Validate layout against known predefined layouts?
@@ -134,10 +175,10 @@ async def create_slide(
     return result
 
 
-@mcp.tool(
-    name="add_text_to_slide",
-    description="Adds text to a specified slide in a Google Slides presentation.",
-)
+# @mcp.tool(
+#     name="add_text_to_slide",
+#     description="Adds text to a specified slide in a Google Slides presentation.",
+# )
 async def add_text_to_slide(
     presentation_id: str,
     slide_id: str,
@@ -171,7 +212,9 @@ async def add_text_to_slide(
     # Validate shape_type
     valid_shape_types = {"TEXT_BOX"}
     if shape_type not in valid_shape_types:
-        raise ValueError(f"Invalid shape_type '{shape_type}' provided. Must be one of {valid_shape_types}.")
+        raise ValueError(
+            f"Invalid shape_type '{shape_type}' provided. Must be one of {valid_shape_types}."
+        )
 
     slides_service = SlidesService()
     result = slides_service.add_text(
@@ -189,10 +232,10 @@ async def add_text_to_slide(
     return result
 
 
-@mcp.tool(
-    name="add_formatted_text_to_slide",
-    description="Adds rich-formatted text (with bold, italic, etc.) to a slide.",
-)
+# @mcp.tool(
+#     name="add_formatted_text_to_slide",
+#     description="Adds rich-formatted text (with bold, italic, etc.) to a slide.",
+# )
 async def add_formatted_text_to_slide(
     presentation_id: str,
     slide_id: str,
@@ -236,10 +279,10 @@ async def add_formatted_text_to_slide(
     return result
 
 
-@mcp.tool(
-    name="add_bulleted_list_to_slide",
-    description="Adds a bulleted list to a slide in a Google Slides presentation.",
-)
+# @mcp.tool(
+#     name="add_bulleted_list_to_slide",
+#     description="Adds a bulleted list to a slide in a Google Slides presentation.",
+# )
 async def add_bulleted_list_to_slide(
     presentation_id: str,
     slide_id: str,
@@ -283,10 +326,90 @@ async def add_bulleted_list_to_slide(
     return result
 
 
-@mcp.tool(
-    name="add_table_to_slide",
-    description="Adds a table to a slide in a Google Slides presentation.",
-)
+# @mcp.tool(
+#     name="add_image_to_slide",
+#     description="Adds a single image to a slide from a publicly accessible URL with smart sizing. For creating complete slides with multiple elements, use create_slide_with_elements instead for better performance. For full-height coverage, only specify size_height. For full-width coverage, only specify size_width. For exact dimensions, specify both.",
+# )
+async def add_image_to_slide(
+    presentation_id: str,
+    slide_id: str,
+    image_url: str,
+    position_x: float = 100.0,
+    position_y: float = 100.0,
+    size_width: float | None = None,
+    size_height: float | None = None,
+    unit: str = "PT",
+) -> dict[str, Any]:
+    """
+    Add an image to a slide from a publicly accessible URL.
+
+    Args:
+        presentation_id: The ID of the presentation.
+        slide_id: The ID of the slide.
+        image_url: The publicly accessible URL of the image to add.
+        position_x: X coordinate for position (default 100.0).
+        position_y: Y coordinate for position (default 100.0).
+        size_width: Optional width of the image. If not specified, uses original size or scales proportionally with height.
+        size_height: Optional height of the image. If not specified, uses original size or scales proportionally with width.
+        unit: Unit type - "PT" for points or "EMU" for English Metric Units (default "PT").
+
+    Returns:
+        Response data confirming image addition or raises error.
+
+    Note:
+        Image Sizing Best Practices:
+        - For full-height coverage: Only specify size_height parameter
+        - For full-width coverage: Only specify size_width parameter
+        - For exact dimensions: Specify both size_height and size_width
+        - Omitting a dimension allows proportional auto-scaling while maintaining aspect ratio
+    """
+    logger.info(
+        f"Executing add_image_to_slide on slide '{slide_id}' with image '{image_url}'"
+    )
+    logger.info(f"Position: ({position_x}, {position_y}) {unit}")
+    if size_width and size_height:
+        logger.info(f"Size: {size_width} x {size_height} {unit}")
+
+    if not presentation_id or not slide_id or not image_url:
+        raise ValueError("Presentation ID, Slide ID, and Image URL are required")
+
+    # Basic URL validation
+    if not image_url.startswith(("http://", "https://")):
+        raise ValueError("Image URL must be a valid HTTP or HTTPS URL")
+
+    # Validate unit
+    if unit not in ["PT", "EMU"]:
+        raise ValueError(
+            "Unit must be either 'PT' (points) or 'EMU' (English Metric Units)"
+        )
+
+    slides_service = SlidesService()
+
+    # Prepare size parameter
+    size = None
+    if size_width is not None and size_height is not None:
+        size = (size_width, size_height)
+
+    # Use the enhanced add_image method with unit support
+    result = slides_service.add_image_with_unit(
+        presentation_id=presentation_id,
+        slide_id=slide_id,
+        image_url=image_url,
+        position=(position_x, position_y),
+        size=size,
+        unit=unit,
+    )
+
+    if isinstance(result, dict) and result.get("error"):
+        raise ValueError(result.get("message", "Error adding image to slide"))
+
+    return result
+
+
+# @mcp.tool(
+#     name="add_table_to_slide",
+#     description="Adds a table to a slide in a Google Slides presentation.",
+# )
 async def add_table_to_slide(
     presentation_id: str,
     slide_id: str,
@@ -342,10 +465,10 @@ async def add_table_to_slide(
     return result
 
 
-@mcp.tool(
-    name="add_slide_notes",
-    description="Adds presenter notes to a slide in a Google Slides presentation.",
-)
+# @mcp.tool(
+#     name="add_slide_notes",
+#     description="Adds presenter notes to a slide in a Google Slides presentation.",
+# )
 async def add_slide_notes(
     presentation_id: str,
     slide_id: str,
@@ -381,7 +504,6 @@ async def add_slide_notes(
 
 @mcp.tool(
     name="duplicate_slide",
-    description="Duplicates a slide in a Google Slides presentation.",
 )
 async def duplicate_slide(
     presentation_id: str,
@@ -392,10 +514,13 @@ async def duplicate_slide(
     Duplicate a slide in a presentation.
 
     Args:
-        presentation_id: The ID of the presentation.
+        presentation_id: The ID of the presentation where the new slide will be created.
         slide_id: The ID of the slide to duplicate.
         insert_at_index: Optional index where to insert the duplicated slide.
 
+    Crucial Note: The slide_id MUST belong to the SAME presentation specified by presentation_id.
+    You cannot duplicate a slide from one presentation into another using this tool.
+
     Returns:
         Response data with the new slide ID or raises error.
     """
@@ -416,10 +541,9 @@ async def duplicate_slide(
     return result
 
 
-@mcp.tool(
-    name="delete_slide",
-    description="Deletes a slide from a Google Slides presentation.",
-)
+# @mcp.tool(
+#     name="delete_slide",
+# )
 async def delete_slide(
     presentation_id: str,
     slide_id: str,
@@ -434,12 +558,16 @@ async def delete_slide(
     Returns:
         Response data confirming slide deletion or raises error.
     """
-    logger.info(f"Executing delete_slide: slide '{slide_id}' from presentation '{presentation_id}'")
+    logger.info(
+        f"Executing delete_slide: slide '{slide_id}' from presentation '{presentation_id}'"
+    )
     if not presentation_id or not slide_id:
         raise ValueError("Presentation ID and Slide ID are required")
 
     slides_service = SlidesService()
-    result = slides_service.delete_slide(presentation_id=presentation_id, slide_id=slide_id)
+    result = slides_service.delete_slide(
+        presentation_id=presentation_id, slide_id=slide_id
+    )
 
     if isinstance(result, dict) and result.get("error"):
         raise ValueError(result.get("message", "Error deleting slide"))
@@ -447,10 +575,10 @@ async def delete_slide(
     return result
 
 
-@mcp.tool(
-    name="create_presentation_from_markdown",
-    description="Creates a Google Slides presentation from structured Markdown content with enhanced formatting support using markdowndeck.",
-)
+# @mcp.tool(
+#     name="create_presentation_from_markdown",
+#     description="Creates a Google Slides presentation from structured Markdown content with enhanced formatting support using markdowndeck.",
+# )
 async def create_presentation_from_markdown(
     title: str,
     markdown_content: str,
@@ -466,13 +594,604 @@ async def create_presentation_from_markdown(
         Created presentation data or raises error.
     """
     logger.info(f"Executing create_presentation_from_markdown with title '{title}'")
-    if not title or not title.strip() or not markdown_content or not markdown_content.strip():
+    if (
+        not title
+        or not title.strip()
+        or not markdown_content
+        or not markdown_content.strip()
+    ):
         raise ValueError("Title and markdown content are required")
 
     slides_service = SlidesService()
-    result = slides_service.create_presentation_from_markdown(title=title, markdown_content=markdown_content)
+    result = slides_service.create_presentation_from_markdown(
+        title=title, markdown_content=markdown_content
+    )
+
+    if isinstance(result, dict) and result.get("error"):
+        raise ValueError(
+            result.get("message", "Error creating presentation from Markdown")
+        )
+
+    return result
+
+
+# @mcp.tool(
+#     name="create_textbox_with_text",
+# )
+async def create_textbox_with_text(
+    presentation_id: str,
+    slide_id: str,
+    text: str,
+    position_x: float,
+    position_y: float,
+    size_width: float,
+    size_height: float,
+    unit: str = "EMU",
+    element_id: str | None = None,
+    font_family: str = "Arial",
+    font_size: float = 12,
+    text_alignment: str | None = None,
+    vertical_alignment: str | None = None,
+) -> dict[str, Any]:
+    """
+    Create a text box with text, font formatting, and alignment.
+
+    Args:
+        presentation_id: The ID of the presentation.
+        slide_id: The ID of the slide.
+        text: The text content to insert.
+        position_x: X coordinate for position.
+        position_y: Y coordinate for position.
+        size_width: Width of the text box.
+        size_height: Height of the text box.
+        unit: Unit type - "PT" for points or "EMU" for English Metric Units (default "EMU").
+        element_id: Optional custom element ID, auto-generated if not provided.
+        font_family: Font family (e.g., "Playfair Display", "Roboto", "Arial").
+        font_size: Font size in points (e.g., 25, 7.5).
+        text_alignment: Optional horizontal alignment ("LEFT", "CENTER", "RIGHT", "JUSTIFY").
+        vertical_alignment: Optional vertical alignment ("TOP", "MIDDLE", "BOTTOM").
+
+    Returns:
+        Response data confirming text box creation or raises error.
+    """
+    logger.info(f"Executing create_textbox_with_text on slide '{slide_id}'")
+    if not presentation_id or not slide_id or text is None:
+        raise ValueError("Presentation ID, Slide ID, and Text are required")
+
+    slides_service = SlidesService()
+    result = slides_service.create_textbox_with_text(
+        presentation_id=presentation_id,
+        slide_id=slide_id,
+        text=text,
+        position=(position_x, position_y),
+        size=(size_width, size_height),
+        unit=unit,
+        element_id=element_id,
+        font_family=font_family,
+        font_size=font_size,
+        text_alignment=text_alignment,
+        vertical_alignment=vertical_alignment,
+    )
+
+    if isinstance(result, dict) and result.get("error"):
+        raise ValueError(result.get("message", "Error creating text box with text"))
+
+    return result
+
+
+# @mcp.tool(
+#     name="slides_batch_update",
+# )
+async def slides_batch_update(
+    presentation_id: str,
+    requests: list[dict[str, Any]],
+) -> dict[str, Any]:
+    """
+    Apply a list of raw Google Slides API update requests to a presentation.
+    For advanced users familiar with Slides API request structures.
+
+    Args:
+        presentation_id: The ID of the presentation
+        requests: List of Google Slides API request objects (e.g., createShape, insertText, updateTextStyle, createImage, etc.)
+
+    Returns:
+        Response data confirming batch operation or raises error
+
+    Example request structure:
+    [
+        {
+            "createShape": {
+                "objectId": "textbox1",
+                "shapeType": "TEXT_BOX",
+                "elementProperties": {
+                    "pageObjectId": "slide_id",
+                    "size": {"width": {"magnitude": 300, "unit": "PT"}, "height": {"magnitude": 50, "unit": "PT"}},
+                    "transform": {"translateX": 100, "translateY": 100, "unit": "PT"}
+                }
+            }
+        },
+        {
+            "insertText": {
+                "objectId": "textbox1",
+                "text": "Hello World"
+            }
+        }
+    ]
+    """
+    logger.info(f"Executing slides_batch_update with {len(requests)} requests")
+    if not presentation_id or not requests:
+        raise ValueError("Presentation ID and requests list are required")
+
+    if not isinstance(requests, list):
+        raise ValueError("Requests must be a list of API request objects")
+
+    slides_service = SlidesService()
+    result = slides_service.batch_update(
+        presentation_id=presentation_id, requests=requests
+    )
+
+    if isinstance(result, dict) and result.get("error"):
+        raise ValueError(result.get("message", "Error executing batch update"))
+
+    return result
+
+
+# @mcp.tool(
+#     name="create_slide_from_template_data",
+# )
+async def create_slide_from_template_data(
+    presentation_id: str,
+    slide_id: str,
+    template_data: dict[str, Any],
+) -> dict[str, Any]:
+    """
+    Create a complete slide from template data in a single batch operation.
+
+    Args:
+        presentation_id: The ID of the presentation
+        slide_id: The ID of the slide
+        template_data: Dictionary containing slide elements, example:
+            {
+                "title": {
+                    "text": "John's Company Campaign",
+                    "position": {"x": 32, "y": 35, "width": 330, "height": 40},
+                    "style": {"fontSize": 18, "fontFamily": "Roboto"}
+                },
+                "description": {
+                    "text": "Campaign description...",
+                    "position": {"x": 32, "y": 95, "width": 330, "height": 160},
+                    "style": {"fontSize": 12, "fontFamily": "Roboto"}
+                },
+                "stats": [
+                    {"value": "43.4M", "label": "TOTAL IMPRESSIONS", "position": {"x": 374.5, "y": 268.5}},
+                    {"value": "134K", "label": "TOTAL ENGAGEMENTS", "position": {"x": 516.5, "y": 268.5}},
+                    {"value": "4.8B", "label": "AGGREGATE READERSHIP", "position": {"x": 374.5, "y": 350.5}},
+                    {"value": "$9.1M", "label": "AD EQUIVALENCY", "position": {"x": 516.5, "y": 350.5}}
+                ],
+                "image": {
+                    "url": "https://images.unsplash.com/...",
+                    "position": {"x": 375, "y": 35},
+                    "size": {"width": 285, "height": 215}
+                }
+            }
+
+    Returns:
+        Response data confirming slide creation or raises error
+    """
+    logger.info(f"Executing create_slide_from_template_data on slide '{slide_id}'")
+    if not presentation_id or not slide_id or not template_data:
+        raise ValueError("Presentation ID, Slide ID, and Template Data are required")
+
+    if not isinstance(template_data, dict):
+        raise ValueError("Template data must be a dictionary")
+
+    slides_service = SlidesService()
+    result = slides_service.create_slide_from_template_data(
+        presentation_id=presentation_id, slide_id=slide_id, template_data=template_data
+    )
+
+    if isinstance(result, dict) and result.get("error"):
+        raise ValueError(
+            result.get("message", "Error creating slide from template data")
+        )
+
+    return result
+
+
+@mcp.tool(
+    name="create_slide_with_elements",
+)
+async def create_slide_with_elements(
+    presentation_id: str,
+    slide_id: str | None = None,
+    elements: list[dict[str, Any]] | None = None,
+    background_color: str | None = None,
+    background_image_url: str | None = None,
+    create_slide: bool = False,
+    layout: str = "BLANK",
+    insert_at_index: int | None = None,
+) -> dict[str, Any]:
+    """
+    Create a complete slide with multiple elements in one batch operation.
+    NOW SUPPORTS CREATING THE SLIDE ITSELF - eliminates the two-call pattern!
+
+    Args:
+        presentation_id: The ID of the presentation
+        slide_id: The ID of the slide (optional if create_slide=True)
+        elements: List of element dictionaries (optional, can create empty slide), example:
+            [
+                {
+                    "type": "textbox",
+                    "content": "Slide Title",
+                    "position": {"x": 282, "y": 558, "width": 600, "height": 45},
+                    "style": {
+                        "fontSize": 25,
+                        "fontFamily": "Playfair Display",
+                        "bold": True,
+                        "textAlignment": "CENTER",
+                        "verticalAlignment": "MIDDLE",
+                        "textColor": "#FFFFFF",  # White text
+                        "backgroundColor": "#FFFFFF80"  # Semi-transparent white background
+                    }
+                },
+                {
+                    "type": "textbox",
+                    "content": "Description text...",
+                    "position": {"x": 282, "y": 1327, "width": 600, "height": 234},
+                    "style": {
+                        "fontSize": 12,
+                        "fontFamily": "Roboto",
+                        "color": "#000000",  # Black text (alternative to textColor)
+                        "foregroundColor": "#333333"  # Dark gray text (alternative to textColor/color)
+                    }
+                },
+                {
+                    "type": "textbox",
+                    "content": "43.4M\nTOTAL IMPRESSIONS",
+                    "position": {"x": 333, "y": 4059, "width": 122, "height": 79},
+                    "textRanges": [
+                        {
+                            "startIndex": 0,
+                            "endIndex": 5,
+                            "style": {
+                                "fontSize": 25,
+                                "fontFamily": "Playfair Display",
+                                "bold": True,
+                                "textColor": "#FF0000"  # Red text for the number
+                            }
+                        },
+                        {
+                            "startIndex": 6,
+                            "endIndex": 22,
+                            "style": {
+                                "fontSize": 7.5,
+                                "fontFamily": "Roboto",
+                                "backgroundColor": "#FFFF0080"  # Semi-transparent yellow background for label
+                            }
+                        }
+                    ],
+                    "style": {"textAlignment": "CENTER"}
+                },
+                {
+                    "type": "image",
+                    "content": "https://drive.google.com/file/d/.../view",
+                    "position": {"x": 675, "y": 0, "width": 238, "height": 514}
+                },
+                {
+                    "type": "table",
+                    "content": {
+                        "headers": ["Category", "Metric"],
+                        "rows": [
+                            ["Reach & Visibility", "Total Impressions: 43,431,803"],
+                            ["Engagement", "Total Engagements: 134,431"],
+                            ["Media Value", "Ad Equivalency: $9.1 million"]
+                        ]
+                    },
+                    "position": {"x": 100, "y": 300, "width": 400, "height": 200},
+                    "style": {
+                        "headerStyle": {
+                            "bold": true,
+                            "backgroundColor": "#ff6b6b"
+                        },
+                        "firstColumnBold": true,
+                        "fontSize": 12,
+                        "fontFamily": "Roboto"
+                    }
+                }
+            ]
+        background_color: Optional slide background color (e.g., "#f8cdcd4f")
+        background_image_url: Optional slide background image URL (takes precedence over background_color)
+                             Must be publicly accessible (e.g., "https://drive.google.com/uc?id=FILE_ID")
+        create_slide: If True, creates the slide first. If False, adds elements to existing slide. (default: False)
+        layout: Layout for new slide (BLANK, TITLE_AND_BODY, etc.) - only used if create_slide=True
+        insert_at_index: Position for new slide (only used if create_slide=True)
+
+    Text Color Support:
+        - "textColor" or "color": "#FFFFFF"
+        - "foregroundColor": "#333333"
+        - Supports 6-character and 8-character hex codes with alpha: "#FFFFFF", "#FFFFFF80"
+        - Supports CSS rgba() format: "rgba(255, 255, 255, 0.5)"
+        - Supports RGB objects: {"r": 255, "g": 255, "b": 255} or {"red": 1.0, "green": 1.0, "blue": 1.0}
+
+    Background Color Support:
+        - "backgroundColor": "#FFFFFF80" - Semi-transparent white background
+        - "backgroundColor": "rgba(255, 255, 255, 0.5)" - Semi-transparent white background (CSS format)
+        - Supports same color formats as text colors
+        - 8-character hex codes supported: "#FFFFFF80" (alpha channel properly applied)
+        - CSS rgba() format supported: "rgba(255, 255, 255, 0.5)" (alpha channel properly applied)
+        - CSS rgb() format supported: "rgb(255, 255, 255)" (fully opaque)
+        - Works in main "style" object for entire text box background
+        - Creates semi-transparent background for the entire text box shape
+
+    Background Image Requirements:
+        - Must be publicly accessible without authentication
+        - Maximum file size: 50 MB
+        - Maximum resolution: 25 megapixels
+        - Supported formats: PNG, JPEG, GIF only
+        - HTTPS URLs recommended
+        - Will automatically stretch to fill slide (may distort aspect ratio)
+
+    Advanced textRanges formatting:
+        For mixed formatting within a single textbox, use "textRanges" instead of "style":
+        - textRanges: Array of formatting ranges - now supports TWO formats:
+
+        FORMAT 1 - Content-based (RECOMMENDED - no index calculation needed):
+        "textRanges": [
+            {"content": "43.4M", "style": {"fontSize": 25, "bold": true}},
+            {"content": "TOTAL IMPRESSIONS", "style": {"fontSize": 7.5}}
+        ]
+
+        FORMAT 2 - Index-based (legacy support):
+        "textRanges": [
+            {"startIndex": 0, "endIndex": 5, "style": {"fontSize": 25, "bold": true}},
+            {"startIndex": 6, "endIndex": 23, "style": {"fontSize": 7.5}}
+        ]
+
+        - Content-based ranges automatically find text and calculate indices
+        - Index-based ranges include auto-correction for common off-by-one errors
+        - Allows different fonts, sizes, colors, and formatting for different parts of text
+        - Perfect for stats with large numbers + small labels in same textbox
+        - Each textRange can have its own textColor and backgroundColor
+
+    Table Formatting Best Practices:
+        - Use "firstColumnBold": true to emphasize categories/left column
+        - Headers: Bold with colored backgrounds (e.g., "#ff6b6b" for brand consistency)
+        - Structure: Clear headers with organized data rows
+
+    Usage Examples:
+        # NEW OPTIMIZED WAY - Single API call to create slide with elements:
+        result = await create_slide_with_elements(
+            presentation_id="abc123",
+            elements=[
+                {
+                    "type": "textbox",
+                    "content": "Slide Title",
+                    "position": {"x": 100, "y": 100, "width": 400, "height": 50},
+                    "style": {"fontSize": 18, "bold": True, "textColor": "#FFFFFF"}
+                },
+                {
+                    "type": "image",
+                    "content": "https://images.unsplash.com/...",
+                    "position": {"x": 375, "y": 35, "width": 285, "height": 215}
+                }
+            ],
+            create_slide=True,  # Creates slide AND adds elements
+            layout="BLANK",
+            background_color="#f8cdcd4f"
+        )
+        # Returns: {"slideId": "auto_generated_id", "slideCreated": True, "elementsAdded": 2}
+
+        # Add elements to existing slide (original behavior):
+        result = await create_slide_with_elements(
+            presentation_id="abc123",
+            slide_id="existing_slide_123",
+            elements=[...],
+            create_slide=False  # Only adds elements (default)
+        )
+
+        # Create slide without elements (just background):
+        result = await create_slide_with_elements(
+            presentation_id="abc123",
+            create_slide=True,
+            background_image_url="https://images.unsplash.com/..."
+        )
+
+    Returns:
+        Response data confirming slide creation or raises error
+    """
+    logger.info(
+        f"Executing create_slide_with_elements (create_slide={create_slide}, elements={len(elements or [])})"
+    )
+
+    if not presentation_id:
+        raise ValueError("Presentation ID is required")
+
+    if not create_slide and not slide_id:
+        raise ValueError("slide_id is required when create_slide=False")
+
+    if elements and not isinstance(elements, list):
+        raise ValueError("Elements must be a list")
+
+    slides_service = SlidesService()
+    result = slides_service.create_slide_with_elements(
+        presentation_id=presentation_id,
+        slide_id=slide_id,
+        elements=elements,
+        background_color=background_color,
+        background_image_url=background_image_url,
+        create_slide=create_slide,
+        layout=layout,
+        insert_at_index=insert_at_index,
+    )
+
+    if isinstance(result, dict) and result.get("error"):
+        raise ValueError(result.get("message", "Error creating slide with elements"))
+
+    return result
+
+
+# @mcp.tool(
+#     name="set_slide_background",
+# )
+async def set_slide_background(
+    presentation_id: str,
+    slide_id: str,
+    background_color: str | None = None,
+    background_image_url: str | None = None,
+) -> dict[str, Any]:
+    """
+    Set the background of a slide to either a solid color or an image.
+
+    Args:
+        presentation_id: The ID of the presentation
+        slide_id: The ID of the slide
+        background_color: Optional background color (e.g., "#f8cdcd4f", "#ffffff")
+        background_image_url: Optional background image URL (takes precedence over color)
+                             Must be publicly accessible (e.g., "https://drive.google.com/uc?id=FILE_ID")
+
+    Background Image Requirements:
+        - Must be publicly accessible without authentication
+        - Maximum file size: 50 MB
+        - Maximum resolution: 25 megapixels
+        - Supported formats: PNG, JPEG, GIF only
+        - HTTPS URLs recommended
+        - Will automatically stretch to fill entire slide
+        - May distort aspect ratio to fit slide dimensions
+
+    Returns:
+        Response data confirming background update or raises error
+    """
+    logger.info(f"Setting background for slide '{slide_id}'")
+    if not presentation_id or not slide_id:
+        raise ValueError("Presentation ID and Slide ID are required")
+
+    if not background_color and not background_image_url:
+        raise ValueError(
+            "Either background_color or background_image_url must be provided"
+        )
+
+    slides_service = SlidesService()
+
+    # Create the appropriate background request
+    if background_image_url:
+        logger.info(f"Setting slide background image: {background_image_url}")
+        requests = [
+            {
+                "updatePageProperties": {
+                    "objectId": slide_id,
+                    "pageProperties": {
+                        "pageBackgroundFill": {
+                            "stretchedPictureFill": {"contentUrl": background_image_url}
+                        }
+                    },
+                    "fields": "pageBackgroundFill",
+                }
+            }
+        ]
+    else:
+        logger.info(f"Setting slide background color: {background_color}")
+        requests = [
+            {
+                "updatePageProperties": {
+                    "objectId": slide_id,
+                    "pageProperties": {
+                        "pageBackgroundFill": {
+                            "solidFill": {
+                                "color": {
+                                    "rgbColor": slides_service._hex_to_rgb(
+                                        background_color or "#ffffff"
+                                    )
+                                }
+                            }
+                        }
+                    },
+                    "fields": "pageBackgroundFill.solidFill.color",
+                }
+            }
+        ]
+
+    result = slides_service.batch_update(presentation_id, requests)
+
+    if isinstance(result, dict) and result.get("error"):
+        raise ValueError(result.get("message", "Error setting slide background"))
+
+    return result
+
+
+# @mcp.tool(
+#     name="convert_template_zones_to_pt",
+# )
+async def convert_template_zones_to_pt(
+    template_zones: dict[str, Any],
+) -> dict[str, Any]:
+    """
+    Convert template zones coordinates from EMU to PT for easier slide element creation.
+
+    Args:
+        template_zones: Template zones from extract_template_zones_only
+
+    Returns:
+        Template zones with additional PT coordinates (x_pt, y_pt, width_pt, height_pt)
+    """
+    logger.info(f"Converting {len(template_zones)} template zones to PT coordinates")
+    if not template_zones:
+        raise ValueError("Template zones are required")
+
+    slides_service = SlidesService()
+    result = slides_service.convert_template_zones_to_pt(template_zones)
+
+    return {"success": True, "converted_zones": result}
+
+
+# @mcp.tool(
+#     name="update_text_formatting",
+# )
+async def update_text_formatting(
+    presentation_id: str,
+    element_id: str,
+    formatted_text: str,
+    font_size: float | None = None,
+    font_family: str | None = None,
+    text_alignment: str | None = None,
+    vertical_alignment: str | None = None,
+    start_index: int | None = None,
+    end_index: int | None = None,
+) -> dict[str, Any]:
+    """
+    Update formatting of text in an existing text box.
+
+    Args:
+        presentation_id: The ID of the presentation
+        element_id: The ID of the text box element
+        formatted_text: Text with formatting markers (**, *, etc.)
+        font_size: Optional font size in points (e.g., 25, 7.5)
+        font_family: Optional font family (e.g., "Playfair Display", "Roboto", "Arial")
+        text_alignment: Optional horizontal alignment ("LEFT", "CENTER", "RIGHT", "JUSTIFY")
+        vertical_alignment: Optional vertical alignment ("TOP", "MIDDLE", "BOTTOM")
+        start_index: Optional start index for applying formatting to specific range (0-based)
+        end_index: Optional end index for applying formatting to specific range (exclusive)
+
+    Returns:
+        Response data or error information
+    """
+    logger.info(f"Executing update_text_formatting on element '{element_id}'")
+    if not presentation_id or not element_id or not formatted_text:
+        raise ValueError("Presentation ID, Element ID, and Formatted Text are required")
+
+    slides_service = SlidesService()
+    result = slides_service.update_text_formatting(
+        presentation_id=presentation_id,
+        element_id=element_id,
+        formatted_text=formatted_text,
+        font_size=font_size,
+        font_family=font_family,
+        text_alignment=text_alignment,
+        vertical_alignment=vertical_alignment,
+        start_index=start_index,
+        end_index=end_index,
+    )
 
     if isinstance(result, dict) and result.get("error"):
-        raise ValueError(result.get("message", "Error creating presentation from Markdown"))
+        raise ValueError(result.get("message", "Error updating text formatting"))
 
     return result