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

google_workspace_mcp/services/slides.py

@@ -12,7 +12,6 @@ from markdowndeck import create_presentation
 from google_workspace_mcp.auth import gauth
 from google_workspace_mcp.services.base import BaseGoogleService
 from google_workspace_mcp.utils.markdown_slides import MarkdownSlidesConverter
-from google_workspace_mcp.utils.unit_conversion import convert_template_zones
 
 logger = logging.getLogger(__name__)
 
@@ -783,13 +782,12 @@ class SlidesService(BaseGoogleService):
             Response data or error information
         """
         try:
-            # Create a unique element ID (FIX: Actually assign the variable!)
-            image_id = f"image_{slide_id}_{hash(image_url) % 10000}"
+            # Create a unique element ID
+            f"image_{slide_id}_{hash(image_url) % 10000}"
 
             # Define the base request
             create_image_request = {
                 "createImage": {
-                    "objectId": image_id,  # FIX: Add the missing objectId
                     "url": image_url,
                     "elementProperties": {
                         "pageObjectId": slide_id,
@@ -798,7 +796,7 @@ class SlidesService(BaseGoogleService):
                             "scaleY": 1,
                             "translateX": position[0],
                             "translateY": position[1],
-                            "unit": "PT",  # Could use "EMU" to match docs
+                            "unit": "PT",
                         },
                     },
                 }
@@ -843,90 +841,6 @@ class SlidesService(BaseGoogleService):
         except Exception as e:
             return self.handle_api_error("add_image", e)
 
-    def add_image_with_unit(
-        self,
-        presentation_id: str,
-        slide_id: str,
-        image_url: str,
-        position: tuple[float, float] = (100, 100),
-        size: tuple[float, float] | None = None,
-        unit: str = "PT",
-    ) -> dict[str, Any]:
-        """
-        Add an image to a slide from a URL with support for different units.
-
-        Args:
-            presentation_id: The ID of the presentation
-            slide_id: The ID of the slide
-            image_url: The URL of the image to add
-            position: Tuple of (x, y) coordinates for position
-            size: Optional tuple of (width, height) for the image
-            unit: Unit type - "PT" for points or "EMU" for English Metric Units
-
-        Returns:
-            Response data or error information
-        """
-        try:
-            # Create a unique element ID
-            image_id = f"image_{slide_id}_{hash(image_url) % 10000}"
-
-            # Define the base request
-            create_image_request = {
-                "createImage": {
-                    "objectId": image_id,
-                    "url": image_url,
-                    "elementProperties": {
-                        "pageObjectId": slide_id,
-                        "transform": {
-                            "scaleX": 1,
-                            "scaleY": 1,
-                            "translateX": position[0],
-                            "translateY": position[1],
-                            "unit": unit,  # Use the specified unit
-                        },
-                    },
-                }
-            }
-
-            # Add size if specified
-            if size:
-                create_image_request["createImage"]["elementProperties"]["size"] = {
-                    "width": {"magnitude": size[0], "unit": unit},
-                    "height": {"magnitude": size[1], "unit": unit},
-                }
-
-            logger.info(
-                f"Sending API request to create image with {unit} units: {json.dumps(create_image_request, indent=2)}"
-            )
-
-            # Execute the request
-            response = (
-                self.service.presentations()
-                .batchUpdate(
-                    presentationId=presentation_id,
-                    body={"requests": [create_image_request]},
-                )
-                .execute()
-            )
-
-            # Extract the image ID from the response
-            if "replies" in response and len(response["replies"]) > 0:
-                image_id = response["replies"][0].get("createImage", {}).get("objectId")
-                logger.info(
-                    f"API response for image creation: {json.dumps(response, indent=2)}"
-                )
-                return {
-                    "presentationId": presentation_id,
-                    "slideId": slide_id,
-                    "imageId": image_id,
-                    "operation": "add_image_with_unit",
-                    "result": "success",
-                }
-
-            return response
-        except Exception as e:
-            return self.handle_api_error("add_image_with_unit", e)
-
     def add_table(
         self,
         presentation_id: str,
@@ -1120,9 +1034,7 @@ class SlidesService(BaseGoogleService):
 
             # If insert location is specified
             if insert_at_index is not None:
-                duplicate_request["duplicateObject"]["insertionIndex"] = str(
-                    insert_at_index
-                )
+                duplicate_request["duplicateObject"]["insertionIndex"] = insert_at_index
 
             logger.info(
                 f"Sending API request to duplicate slide: {json.dumps(duplicate_request, indent=2)}"
@@ -1159,1777 +1071,78 @@ class SlidesService(BaseGoogleService):
         except Exception as e:
             return self.handle_api_error("duplicate_slide", e)
 
-    def calculate_optimal_font_size(
-        self,
-        text: str,
-        box_width: float,
-        box_height: float,
-        font_family: str = "Arial",
-        max_font_size: int = 48,
-        min_font_size: int = 8,
-    ) -> int:
-        """
-        Calculate optimal font size to fit text within given dimensions.
-        Uses simple estimation since PIL may not be available.
-        """
-        try:
-            # Try to import PIL for accurate measurement
-            from PIL import Image, ImageDraw, ImageFont
-
-            def get_text_dimensions(text, font_size, font_family):
-                try:
-                    img = Image.new("RGB", (1000, 1000), color="white")
-                    draw = ImageDraw.Draw(img)
-
-                    try:
-                        font = ImageFont.truetype(f"{font_family}.ttf", font_size)
-                    except:
-                        font = ImageFont.load_default()
-
-                    bbox = draw.textbbox((0, 0), text, font=font)
-                    text_width = bbox[2] - bbox[0]
-                    text_height = bbox[3] - bbox[1]
-
-                    return text_width, text_height
-                except Exception:
-                    # Fallback calculation
-                    char_width = font_size * 0.6
-                    text_width = len(text) * char_width
-                    text_height = font_size * 1.2
-                    return text_width, text_height
-
-            # Binary search for optimal font size
-            low, high = min_font_size, max_font_size
-            optimal_size = min_font_size
-
-            while low <= high:
-                mid = (low + high) // 2
-                text_width, text_height = get_text_dimensions(text, mid, font_family)
-
-                if text_width <= box_width and text_height <= box_height:
-                    optimal_size = mid
-                    low = mid + 1
-                else:
-                    high = mid - 1
-
-            return optimal_size
-
-        except ImportError:
-            # Fallback to simple estimation if PIL not available
-            logger.info("PIL not available, using simple font size estimation")
-            chars_per_line = int(box_width / (12 * 0.6))  # Base font size 12
-
-            if len(text) <= chars_per_line:
-                return min(max_font_size, 12)
-
-            scale_factor = chars_per_line / len(text)
-            return max(min_font_size, int(12 * scale_factor))
-
-    def create_textbox_with_text(
+    def embed_sheets_chart(
         self,
         presentation_id: str,
         slide_id: str,
-        text: str,
+        spreadsheet_id: str,
+        chart_id: int,
         position: tuple[float, float],
         size: tuple[float, 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,
-        auto_size_font: bool = False,
     ) -> dict[str, Any]:
         """
-        Create a text box with text, font formatting, and alignment.
+        Embeds a chart from Google Sheets into a Google Slides presentation.
 
         Args:
-            presentation_id: The ID of the presentation
-            slide_id: The ID of the slide (page)
-            text: The text content to insert
-            position: Tuple of (x, y) coordinates for position
-            size: Tuple of (width, height) for 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 to use (default "Arial")
-            font_size: Font size in points (default 12)
-            text_alignment: Optional horizontal alignment ("LEFT", "CENTER", "RIGHT", "JUSTIFY")
-            vertical_alignment: Optional vertical alignment ("TOP", "MIDDLE", "BOTTOM")
-            auto_size_font: Whether to automatically calculate font size to fit (default False - DEPRECATED)
+            presentation_id: The ID of the presentation.
+            slide_id: The ID of the slide to add the chart to.
+            spreadsheet_id: The ID of the Google Sheet containing the chart.
+            chart_id: The ID of the chart within the sheet.
+            position: Tuple of (x, y) coordinates for position in PT.
+            size: Tuple of (width, height) for the chart size in PT.
 
         Returns:
-            Response data or error information
+            The API response from the batchUpdate call.
         """
         try:
-            # Validate unit
-            if unit not in ["PT", "EMU"]:
-                raise ValueError(
-                    "Unit must be either 'PT' (points) or 'EMU' (English Metric Units)"
-                )
-
-            # Generate element ID if not provided
-            if element_id is None:
-                import time
-
-                element_id = f"TextBox_{int(time.time() * 1000)}"
-
-            # Convert size to API format
-            width = {"magnitude": size[0], "unit": unit}
-            height = {"magnitude": size[1], "unit": unit}
-
-            # Use provided font size instead of calculation
-            if auto_size_font:
-                logger.warning(
-                    "auto_size_font is deprecated - using provided font_size instead"
-                )
+            element_id = f"chart_{chart_id}_{int(__import__('time').time() * 1000)}"
+            logger.info(
+                f"Embedding chart {chart_id} from sheet {spreadsheet_id} into slide {slide_id}"
+            )
 
-            # Build requests with proper sequence
             requests = [
-                # Step 1: Create text box shape (no autofit - API limitation)
                 {
-                    "createShape": {
+                    "createSheetsChart": {
                         "objectId": element_id,
-                        "shapeType": "TEXT_BOX",
+                        "spreadsheetId": spreadsheet_id,
+                        "chartId": chart_id,
+                        "linkingMode": "LINKED",
                         "elementProperties": {
                             "pageObjectId": slide_id,
-                            "size": {"height": height, "width": width},
+                            "size": {
+                                "width": {"magnitude": size[0], "unit": "PT"},
+                                "height": {"magnitude": size[1], "unit": "PT"},
+                            },
                             "transform": {
                                 "scaleX": 1,
                                 "scaleY": 1,
                                 "translateX": position[0],
                                 "translateY": position[1],
-                                "unit": unit,
+                                "unit": "PT",
                             },
                         },
                     }
-                },
-                # Step 2: Set autofit to NONE (only supported value)
-                {
-                    "updateShapeProperties": {
-                        "objectId": element_id,
-                        "shapeProperties": {"autofit": {"autofitType": "NONE"}},
-                        "fields": "autofit.autofitType",
-                    }
-                },
-                # Step 3: Insert text into the text box
-                {
-                    "insertText": {
-                        "objectId": element_id,
-                        "insertionIndex": 0,
-                        "text": text,
-                    }
-                },
-                # Step 4: Apply font size and family
-                {
-                    "updateTextStyle": {
-                        "objectId": element_id,
-                        "textRange": {"type": "ALL"},
-                        "style": {
-                            "fontSize": {"magnitude": font_size, "unit": "PT"},
-                            "fontFamily": font_family,
-                        },
-                        "fields": "fontSize,fontFamily",
-                    }
-                },
-            ]
-
-            # Step 5: Add text alignment if specified
-            if text_alignment is not None:
-                alignment_map = {
-                    "LEFT": "START",
-                    "CENTER": "CENTER",
-                    "RIGHT": "END",
-                    "JUSTIFY": "JUSTIFIED",
                 }
+            ]
 
-                api_alignment = alignment_map.get(text_alignment.upper())
-                if api_alignment:
-                    requests.append(
-                        {
-                            "updateParagraphStyle": {
-                                "objectId": element_id,
-                                "textRange": {"type": "ALL"},
-                                "style": {"alignment": api_alignment},
-                                "fields": "alignment",
-                            }
-                        }
-                    )
-
-            # Step 6: Add vertical alignment if specified
-            if vertical_alignment is not None:
-                valign_map = {"TOP": "TOP", "MIDDLE": "MIDDLE", "BOTTOM": "BOTTOM"}
-
-                api_valign = valign_map.get(vertical_alignment.upper())
-                if api_valign:
-                    requests.append(
-                        {
-                            "updateShapeProperties": {
-                                "objectId": element_id,
-                                "shapeProperties": {"contentAlignment": api_valign},
-                                "fields": "contentAlignment",
-                            }
-                        }
-                    )
-
-            logger.info(
-                f"Creating text box with font {font_family} {font_size}pt, align: {text_alignment}/{vertical_alignment}"
-            )
-
-            # Execute the request
-            response = (
-                self.service.presentations()
-                .batchUpdate(
-                    presentationId=presentation_id, body={"requests": requests}
-                )
-                .execute()
-            )
-
-            logger.info(f"Text box creation response: {json.dumps(response, indent=2)}")
-
-            # Extract object ID from response if available
-            created_object_id = None
-            if "replies" in response and len(response["replies"]) > 0:
-                create_shape_response = response["replies"][0].get("createShape")
-                if create_shape_response:
-                    created_object_id = create_shape_response.get("objectId")
-
-            return {
-                "presentationId": presentation_id,
-                "slideId": slide_id,
-                "elementId": created_object_id or element_id,
-                "text": text,
-                "fontSize": font_size,
-                "fontFamily": font_family,
-                "textAlignment": text_alignment,
-                "verticalAlignment": vertical_alignment,
-                "operation": "create_textbox_with_text",
-                "result": "success",
-                "response": response,
-            }
-        except Exception as e:
-            return self.handle_api_error("create_textbox_with_text", e)
-
-    def batch_update(
-        self, presentation_id: str, requests: list[dict[str, Any]]
-    ) -> dict[str, Any]:
-        """
-        Apply a list of raw Google Slides API update requests to a presentation in a single operation.
-        For advanced users familiar with Slides API request structures.
-        Allows creating multiple elements (text boxes, images, shapes) in a single API call.
-
-        Args:
-            presentation_id: The ID of the presentation
-            requests: List of Google Slides API request objects
-
-        Returns:
-            API response data or error information
-        """
-        try:
-            logger.info(
-                f"Executing batch update with {len(requests)} requests on presentation {presentation_id}"
-            )
-
-            # Execute all requests in a single batch operation
-            response = (
-                self.service.presentations()
-                .batchUpdate(
-                    presentationId=presentation_id, body={"requests": requests}
+            response = self.batch_update(presentation_id, requests)
+            if response.get("error"):
+                raise ValueError(
+                    response.get("message", "Batch update for chart embedding failed")
                 )
-                .execute()
-            )
 
-            logger.info(
-                f"Batch update completed successfully. Response: {json.dumps(response, indent=2)}"
+            created_element_id = (
+                response.get("replies", [{}])[0]
+                .get("createSheetsChart", {})
+                .get("objectId")
             )
 
             return {
-                "presentationId": presentation_id,
-                "operation": "batch_update",
-                "requestCount": len(requests),
-                "result": "success",
-                "replies": response.get("replies", []),
-                "writeControl": response.get("writeControl", {}),
+                "success": True,
+                "presentation_id": presentation_id,
+                "slide_id": slide_id,
+                "element_id": created_element_id or element_id,
             }
-        except Exception as e:
-            return self.handle_api_error("batch_update", e)
-
-    def create_slide_from_template_data(
-        self,
-        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 data structure:
-                {
-                    "title": {"text": "...", "position": {"x": 32, "y": 35, "width": 330, "height": 40}, "style": {"fontSize": 18, "fontFamily": "Roboto"}},
-                    "description": {"text": "...", "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}},
-                        # ... more stats
-                    ],
-                    "image": {"url": "...", "position": {"x": 375, "y": 35}, "size": {"width": 285, "height": 215}}
-                }
-
-        Returns:
-            Response data or error information
-        """
-        try:
-            import time
-
-            requests = []
-            element_counter = 0
-
-            # Build title element
-            if "title" in template_data:
-                title_id = f"title_{int(time.time() * 1000)}_{element_counter}"
-                requests.extend(
-                    self._build_textbox_requests(
-                        title_id, slide_id, template_data["title"]
-                    )
-                )
-                element_counter += 1
-
-            # Build description element
-            if "description" in template_data:
-                desc_id = f"description_{int(time.time() * 1000)}_{element_counter}"
-                requests.extend(
-                    self._build_textbox_requests(
-                        desc_id, slide_id, template_data["description"]
-                    )
-                )
-                element_counter += 1
-
-            # Build stats elements
-            for i, stat in enumerate(template_data.get("stats", [])):
-                # Stat value
-                stat_id = f"stat_value_{int(time.time() * 1000)}_{i}"
-                stat_data = {
-                    "text": stat["value"],
-                    "position": stat["position"],
-                    "style": {
-                        "fontSize": 25,
-                        "fontFamily": "Playfair Display",
-                        "bold": True,
-                    },
-                }
-                requests.extend(
-                    self._build_textbox_requests(stat_id, slide_id, stat_data)
-                )
-
-                # Stat label
-                label_id = f"stat_label_{int(time.time() * 1000)}_{i}"
-                label_pos = {
-                    "x": stat["position"]["x"],
-                    "y": stat["position"]["y"] + 33.5,  # Position label below value
-                    "width": stat["position"].get("width", 142),
-                    "height": stat["position"].get("height", 40),
-                }
-                label_data = {
-                    "text": stat["label"],
-                    "position": label_pos,
-                    "style": {"fontSize": 7.5, "fontFamily": "Roboto"},
-                }
-                requests.extend(
-                    self._build_textbox_requests(label_id, slide_id, label_data)
-                )
-
-            # Build image element
-            if "image" in template_data:
-                image_id = f"image_{int(time.time() * 1000)}_{element_counter}"
-                requests.append(
-                    self._build_image_request(
-                        image_id, slide_id, template_data["image"]
-                    )
-                )
-
-            logger.info(f"Built {len(requests)} requests for slide creation")
-
-            # Execute batch update
-            return self.batch_update(presentation_id, requests)
 
         except Exception as e:
-            return self.handle_api_error("create_slide_from_template_data", e)
-
-    def _build_textbox_requests(
-        self, object_id: str, slide_id: str, textbox_data: dict[str, Any]
-    ) -> list[dict[str, Any]]:
-        """Helper to build textbox creation requests"""
-        pos = textbox_data["position"]
-        style = textbox_data.get("style", {})
-
-        requests = [
-            # Create shape
-            {
-                "createShape": {
-                    "objectId": object_id,
-                    "shapeType": "TEXT_BOX",
-                    "elementProperties": {
-                        "pageObjectId": slide_id,
-                        "size": {
-                            "width": {"magnitude": pos.get("width", 142), "unit": "PT"},
-                            "height": {
-                                "magnitude": pos.get("height", 40),
-                                "unit": "PT",
-                            },
-                        },
-                        "transform": {
-                            "scaleX": 1,
-                            "scaleY": 1,
-                            "translateX": pos["x"],
-                            "translateY": pos["y"],
-                            "unit": "PT",
-                        },
-                    },
-                }
-            },
-            # Insert text
-            {"insertText": {"objectId": object_id, "text": textbox_data["text"]}},
-        ]
-
-        # Add formatting if specified
-        if style:
-            format_request = {
-                "updateTextStyle": {
-                    "objectId": object_id,
-                    "textRange": {"type": "ALL"},
-                    "style": {},
-                    "fields": "",
-                }
-            }
-
-            if "fontSize" in style:
-                format_request["updateTextStyle"]["style"]["fontSize"] = {
-                    "magnitude": style["fontSize"],
-                    "unit": "PT",
-                }
-                format_request["updateTextStyle"]["fields"] += "fontSize,"
-
-            if "fontFamily" in style:
-                format_request["updateTextStyle"]["style"]["fontFamily"] = style[
-                    "fontFamily"
-                ]
-                format_request["updateTextStyle"]["fields"] += "fontFamily,"
-
-            if style.get("bold"):
-                format_request["updateTextStyle"]["style"]["bold"] = True
-                format_request["updateTextStyle"]["fields"] += "bold,"
-
-            # Clean up trailing comma
-            format_request["updateTextStyle"]["fields"] = format_request[
-                "updateTextStyle"
-            ]["fields"].rstrip(",")
-
-            if format_request["updateTextStyle"][
-                "fields"
-            ]:  # Only add if there are fields to update
-                requests.append(format_request)
-
-        return requests
-
-    def _build_image_request(
-        self, object_id: str, slide_id: str, image_data: dict[str, Any]
-    ) -> dict[str, Any]:
-        """Helper to build image creation request"""
-        pos = image_data["position"]
-        size = image_data.get("size", {})
-
-        request = {
-            "createImage": {
-                "objectId": object_id,
-                "url": image_data["url"],
-                "elementProperties": {
-                    "pageObjectId": slide_id,
-                    "transform": {
-                        "scaleX": 1,
-                        "scaleY": 1,
-                        "translateX": pos["x"],
-                        "translateY": pos["y"],
-                        "unit": "PT",
-                    },
-                },
-            }
-        }
-
-        # Add size if specified
-        if size:
-            request["createImage"]["elementProperties"]["size"] = {
-                "width": {"magnitude": size["width"], "unit": "PT"},
-                "height": {"magnitude": size["height"], "unit": "PT"},
-            }
-
-        return request
-
-    def create_slide_with_elements(
-        self,
-        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 a single 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": "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"]
-                            ]
-                        },
-                        "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)
-            - Works in main "style" object for entire text box background
-            - Creates semi-transparent background for the entire text box shape
-
-        Returns:
-            Response data or error information
-        """
-        try:
-            import time
-
-            requests = []
-            final_slide_id = slide_id
-
-            # Step 1: Create slide if requested
-            if create_slide:
-                if not final_slide_id:
-                    final_slide_id = f"slide_{int(time.time() * 1000)}"
-
-                slide_request = {
-                    "createSlide": {
-                        "objectId": final_slide_id,
-                        "slideLayoutReference": {"predefinedLayout": layout},
-                    }
-                }
-
-                if insert_at_index is not None:
-                    slide_request["createSlide"]["insertionIndex"] = insert_at_index
-
-                requests.append(slide_request)
-                logger.info(f"Added createSlide request for slide ID: {final_slide_id}")
-            elif not final_slide_id:
-                raise ValueError("slide_id is required when create_slide=False")
-
-            # Step 2: Set background image or color if specified
-            if final_slide_id and (background_image_url or background_color):
-                if background_image_url:
-                    logger.info(
-                        f"Setting slide background image: {background_image_url}"
-                    )
-                    requests.append(
-                        {
-                            "updatePageProperties": {
-                                "objectId": final_slide_id,
-                                "pageProperties": {
-                                    "pageBackgroundFill": {
-                                        "stretchedPictureFill": {
-                                            "contentUrl": background_image_url
-                                        }
-                                    }
-                                },
-                                "fields": "pageBackgroundFill",
-                            }
-                        }
-                    )
-                elif background_color:
-                    logger.info(f"Setting slide background color: {background_color}")
-                    requests.append(
-                        {
-                            "updatePageProperties": {
-                                "objectId": final_slide_id,
-                                "pageProperties": {
-                                    "pageBackgroundFill": {
-                                        "solidFill": {
-                                            "color": {
-                                                "rgbColor": self._hex_to_rgb(
-                                                    background_color
-                                                )
-                                            }
-                                        }
-                                    }
-                                },
-                                "fields": "pageBackgroundFill.solidFill.color",
-                            }
-                        }
-                    )
-
-            # Step 3: Process each element
-            if elements and final_slide_id:
-                for i, element in enumerate(elements):
-                    element_id = f"element_{int(time.time() * 1000)}_{i}"
-
-                    if element["type"] == "textbox":
-                        requests.extend(
-                            self._build_textbox_requests_generic(
-                                element_id, final_slide_id, element
-                            )
-                        )
-                    elif element["type"] == "image":
-                        requests.append(
-                            self._build_image_request_generic(
-                                element_id, final_slide_id, element
-                            )
-                        )
-                    elif element["type"] == "table":
-                        requests.extend(
-                            self._build_table_request_generic(
-                                element_id, final_slide_id, element
-                            )
-                        )
-
-            logger.info(
-                f"Built {len(requests)} requests for slide (create_slide={create_slide}, elements={len(elements or [])})"
-            )
-
-            # Execute batch update
-            if requests:
-                batch_result = self.batch_update(presentation_id, requests)
-
-                # Extract slide ID from response if we created a new slide
-                if create_slide and batch_result.get("replies"):
-                    # The first reply should be the createSlide response
-                    create_slide_reply = batch_result["replies"][0].get(
-                        "createSlide", {}
-                    )
-                    if create_slide_reply:
-                        final_slide_id = create_slide_reply.get(
-                            "objectId", final_slide_id
-                        )
-
-                return {
-                    "presentationId": presentation_id,
-                    "slideId": final_slide_id,
-                    "operation": (
-                        "create_slide_with_elements"
-                        if create_slide
-                        else "update_slide_with_elements"
-                    ),
-                    "result": "success",
-                    "slideCreated": create_slide,
-                    "elementsAdded": len(elements or []),
-                    "totalRequests": len(requests),
-                    "batchResult": batch_result,
-                }
-            else:
-                return {
-                    "presentationId": presentation_id,
-                    "slideId": final_slide_id,
-                    "operation": "no_operation",
-                    "result": "success",
-                    "message": "No requests generated",
-                }
-
-        except Exception as e:
-            return self.handle_api_error("create_slide_with_elements", e)
-
-    def _build_textbox_requests_generic(
-        self, object_id: str, slide_id: str, element: dict[str, Any]
-    ) -> list[dict[str, Any]]:
-        """Generic helper to build textbox creation requests with support for mixed text formatting"""
-        pos = element["position"]
-        style = element.get("style", {})
-        text_ranges = element.get("textRanges", None)
-
-        requests = [
-            # Create shape
-            {
-                "createShape": {
-                    "objectId": object_id,
-                    "shapeType": "TEXT_BOX",
-                    "elementProperties": {
-                        "pageObjectId": slide_id,
-                        "size": {
-                            "width": {"magnitude": pos["width"], "unit": "PT"},
-                            "height": {"magnitude": pos["height"], "unit": "PT"},
-                        },
-                        "transform": {
-                            "scaleX": 1,
-                            "scaleY": 1,
-                            "translateX": pos["x"],
-                            "translateY": pos["y"],
-                            "unit": "PT",
-                        },
-                    },
-                }
-            },
-            # Insert text
-            {"insertText": {"objectId": object_id, "text": element["content"]}},
-        ]
-
-        # Handle mixed text formatting with textRanges
-        if text_ranges:
-            # Convert content-based ranges to index-based ranges automatically
-            processed_ranges = self._process_text_ranges(
-                element["content"], text_ranges
-            )
-
-            for text_range in processed_ranges:
-                range_style = text_range.get("style", {})
-                start_index = text_range.get("startIndex", 0)
-                end_index = text_range.get("endIndex", len(element["content"]))
-
-                if range_style:
-                    format_request = {
-                        "updateTextStyle": {
-                            "objectId": object_id,
-                            "textRange": {
-                                "type": "FIXED_RANGE",
-                                "startIndex": start_index,
-                                "endIndex": end_index,
-                            },
-                            "style": {},
-                            "fields": "",
-                        }
-                    }
-
-                    if "fontSize" in range_style:
-                        format_request["updateTextStyle"]["style"]["fontSize"] = {
-                            "magnitude": range_style["fontSize"],
-                            "unit": "PT",
-                        }
-                        format_request["updateTextStyle"]["fields"] += "fontSize,"
-
-                    if "fontFamily" in range_style:
-                        format_request["updateTextStyle"]["style"]["fontFamily"] = (
-                            range_style["fontFamily"]
-                        )
-                        format_request["updateTextStyle"]["fields"] += "fontFamily,"
-
-                    if range_style.get("bold"):
-                        format_request["updateTextStyle"]["style"]["bold"] = True
-                        format_request["updateTextStyle"]["fields"] += "bold,"
-
-                    # Add foreground color support
-                    if (
-                        "color" in range_style
-                        or "foregroundColor" in range_style
-                        or "textColor" in range_style
-                    ):
-                        color_value = (
-                            range_style.get("color")
-                            or range_style.get("foregroundColor")
-                            or range_style.get("textColor")
-                        )
-                        color_obj = self._parse_color(color_value)
-                        if color_obj:
-                            format_request["updateTextStyle"]["style"][
-                                "foregroundColor"
-                            ] = color_obj
-                            format_request["updateTextStyle"][
-                                "fields"
-                            ] += "foregroundColor,"
-
-                    # Clean up trailing comma and add format request
-                    format_request["updateTextStyle"]["fields"] = format_request[
-                        "updateTextStyle"
-                    ]["fields"].rstrip(",")
-
-                    if format_request["updateTextStyle"]["fields"]:
-                        requests.append(format_request)
-
-        # Add formatting for the entire text if specified and no textRanges
-        elif style:
-            format_request = {
-                "updateTextStyle": {
-                    "objectId": object_id,
-                    "textRange": {"type": "ALL"},
-                    "style": {},
-                    "fields": "",
-                }
-            }
-
-            if "fontSize" in style:
-                format_request["updateTextStyle"]["style"]["fontSize"] = {
-                    "magnitude": style["fontSize"],
-                    "unit": "PT",
-                }
-                format_request["updateTextStyle"]["fields"] += "fontSize,"
-
-            if "fontFamily" in style:
-                format_request["updateTextStyle"]["style"]["fontFamily"] = style[
-                    "fontFamily"
-                ]
-                format_request["updateTextStyle"]["fields"] += "fontFamily,"
-
-            if style.get("bold"):
-                format_request["updateTextStyle"]["style"]["bold"] = True
-                format_request["updateTextStyle"]["fields"] += "bold,"
-
-            # Add foreground color support
-            if "color" in style or "foregroundColor" in style or "textColor" in style:
-                color_value = (
-                    style.get("color")
-                    or style.get("foregroundColor")
-                    or style.get("textColor")
-                )
-                color_obj = self._parse_color(color_value)
-                if color_obj:
-                    format_request["updateTextStyle"]["style"][
-                        "foregroundColor"
-                    ] = color_obj
-                    format_request["updateTextStyle"]["fields"] += "foregroundColor,"
-
-            # Clean up trailing comma and add format request
-            format_request["updateTextStyle"]["fields"] = format_request[
-                "updateTextStyle"
-            ]["fields"].rstrip(",")
-
-            if format_request["updateTextStyle"]["fields"]:
-                requests.append(format_request)
-
-        # Add text alignment (paragraph-level)
-        if style and style.get("textAlignment"):
-            alignment_map = {
-                "LEFT": "START",
-                "CENTER": "CENTER",
-                "RIGHT": "END",
-                "JUSTIFY": "JUSTIFIED",
-            }
-            api_alignment = alignment_map.get(style["textAlignment"].upper(), "START")
-            requests.append(
-                {
-                    "updateParagraphStyle": {
-                        "objectId": object_id,
-                        "textRange": {"type": "ALL"},
-                        "style": {"alignment": api_alignment},
-                        "fields": "alignment",
-                    }
-                }
-            )
-
-        # Add vertical alignment (shape-level)
-        if style and style.get("verticalAlignment"):
-            valign_map = {"TOP": "TOP", "MIDDLE": "MIDDLE", "BOTTOM": "BOTTOM"}
-            api_valign = valign_map.get(style["verticalAlignment"].upper(), "TOP")
-            requests.append(
-                {
-                    "updateShapeProperties": {
-                        "objectId": object_id,
-                        "shapeProperties": {"contentAlignment": api_valign},
-                        "fields": "contentAlignment",
-                    }
-                }
-            )
-
-        # Add text box background color (shape-level) - this is the key fix!
-        if style and style.get("backgroundColor"):
-            color_obj, alpha = self._parse_color_with_alpha(style["backgroundColor"])
-            if color_obj:
-                requests.append(
-                    {
-                        "updateShapeProperties": {
-                            "objectId": object_id,
-                            "shapeProperties": {
-                                "shapeBackgroundFill": {
-                                    "solidFill": {"color": color_obj, "alpha": alpha}
-                                }
-                            },
-                            "fields": "shapeBackgroundFill",
-                        }
-                    }
-                )
-
-        return requests
-
-    def _process_text_ranges(self, content: str, text_ranges: list[dict]) -> list[dict]:
-        """
-        Process textRanges to support both content-based and index-based ranges.
-
-        Args:
-            content: The full text content
-            text_ranges: List of textRange objects that can be either:
-                - Index-based: {"startIndex": 0, "endIndex": 5, "style": {...}}
-                - Content-based: {"content": "43.4M", "style": {...}}
-
-        Returns:
-            List of index-based textRange objects
-        """
-        processed_ranges = []
-
-        for text_range in text_ranges:
-            if "content" in text_range:
-                # Content-based range - find the text in the content
-                target_content = text_range["content"]
-                start_index = content.find(target_content)
-
-                if start_index >= 0:
-                    end_index = start_index + len(target_content)
-                    processed_ranges.append(
-                        {
-                            "startIndex": start_index,
-                            "endIndex": end_index,
-                            "style": text_range.get("style", {}),
-                        }
-                    )
-                else:
-                    # Content not found - log warning but continue
-                    logger.warning(
-                        f"Content '{target_content}' not found in text: '{content}'"
-                    )
-            else:
-                # Index-based range - use as-is but validate indices
-                start_index = text_range.get("startIndex", 0)
-                end_index = text_range.get("endIndex", len(content))
-
-                # Auto-fix common off-by-one errors
-                if end_index == len(content) - 1:
-                    end_index = len(content)
-                    logger.info(
-                        f"Auto-corrected endIndex from {len(content) - 1} to {len(content)}"
-                    )
-
-                # Validate indices
-                if (
-                    start_index >= 0
-                    and end_index <= len(content)
-                    and start_index < end_index
-                ):
-                    processed_ranges.append(
-                        {
-                            "startIndex": start_index,
-                            "endIndex": end_index,
-                            "style": text_range.get("style", {}),
-                        }
-                    )
-                else:
-                    logger.warning(
-                        f"Invalid text range indices: start={start_index}, end={end_index}, content_length={len(content)}"
-                    )
-
-        return processed_ranges
-
-    def _parse_color(self, color_value: str | dict) -> dict | None:
-        """Parse color value into Google Slides API format.
-
-        Args:
-            color_value: Color as hex string (e.g., "#ffffff"), RGB dict, or theme color
-
-        Returns:
-            Color object in Google Slides API format or None if invalid
-        """
-        if not color_value:
-            return None
-
-        # Handle hex color strings
-        if isinstance(color_value, str):
-            if color_value.lower() == "white":
-                color_value = "#ffffff"
-            elif color_value.lower() == "black":
-                color_value = "#000000"
-
-            if color_value.startswith("#"):
-                # Convert hex to RGB
-                try:
-                    hex_color = color_value.lstrip("#")
-                    if len(hex_color) == 6:
-                        r = int(hex_color[0:2], 16) / 255.0
-                        g = int(hex_color[2:4], 16) / 255.0
-                        b = int(hex_color[4:6], 16) / 255.0
-
-                        return {
-                            "opaqueColor": {
-                                "rgbColor": {"red": r, "green": g, "blue": b}
-                            }
-                        }
-                    elif len(hex_color) == 8:
-                        # Handle 8-character hex with alpha (RRGGBBAA)
-                        r = int(hex_color[0:2], 16) / 255.0
-                        g = int(hex_color[2:4], 16) / 255.0
-                        b = int(hex_color[4:6], 16) / 255.0
-                        a = int(hex_color[6:8], 16) / 255.0
-
-                        return {
-                            "opaqueColor": {
-                                "rgbColor": {"red": r, "green": g, "blue": b}
-                            }
-                        }
-                        # Note: Google Slides API doesn't support alpha in text colors directly
-                        # The alpha would need to be handled differently (e.g., using SolidFill with alpha)
-                except ValueError:
-                    logger.warning(f"Invalid hex color format: {color_value}")
-                    return None
-
-        # Handle RGB dict format
-        elif isinstance(color_value, dict):
-            if "r" in color_value and "g" in color_value and "b" in color_value:
-                return {
-                    "opaqueColor": {
-                        "rgbColor": {
-                            "red": color_value["r"] / 255.0,
-                            "green": color_value["g"] / 255.0,
-                            "blue": color_value["b"] / 255.0,
-                        }
-                    }
-                }
-            elif (
-                "red" in color_value
-                and "green" in color_value
-                and "blue" in color_value
-            ):
-                return {
-                    "opaqueColor": {
-                        "rgbColor": {
-                            "red": color_value["red"],
-                            "green": color_value["green"],
-                            "blue": color_value["blue"],
-                        }
-                    }
-                }
-
-        logger.warning(f"Unsupported color format: {color_value}")
-        return None
-
-    def _build_image_request_generic(
-        self, object_id: str, slide_id: str, element: dict[str, Any]
-    ) -> dict[str, Any]:
-        """Generic helper to build image creation request with smart sizing support"""
-        pos = element["position"]
-
-        request = {
-            "createImage": {
-                "objectId": object_id,
-                "url": element["content"],  # For images, content is the URL
-                "elementProperties": {
-                    "pageObjectId": slide_id,
-                    "transform": {
-                        "scaleX": 1,
-                        "scaleY": 1,
-                        "translateX": pos["x"],
-                        "translateY": pos["y"],
-                        "unit": "PT",
-                    },
-                },
-            }
-        }
-
-        # Smart sizing: handle different dimension specifications
-        # IMPORTANT: Google Slides API limitation - createImage requires BOTH width and height
-        # if size is specified, or omit size entirely. Single dimension causes UNIT_UNSPECIFIED error.
-
-        if "width" in pos and "height" in pos and pos["width"] and pos["height"]:
-            # Both dimensions specified - exact sizing
-            request["createImage"]["elementProperties"]["size"] = {
-                "width": {"magnitude": pos["width"], "unit": "PT"},
-                "height": {"magnitude": pos["height"], "unit": "PT"},
-            }
-        elif "height" in pos and pos["height"]:
-            # Only height specified - assume this is for portrait/vertical images
-            # Use a reasonable aspect ratio (3:4 portrait) to calculate width
-            height = pos["height"]
-            width = height * (3.0 / 4.0)  # 3:4 aspect ratio (portrait)
-            logger.info(
-                f"Image height specified ({height}pt), calculating proportional width ({width:.1f}pt) using 3:4 aspect ratio"
-            )
-            request["createImage"]["elementProperties"]["size"] = {
-                "width": {"magnitude": width, "unit": "PT"},
-                "height": {"magnitude": height, "unit": "PT"},
-            }
-        elif "width" in pos and pos["width"]:
-            # Only width specified - assume this is for landscape images
-            # Use a reasonable aspect ratio (16:9 landscape) to calculate height
-            width = pos["width"]
-            height = width * (9.0 / 16.0)  # 16:9 aspect ratio (landscape)
-            logger.info(
-                f"Image width specified ({width}pt), calculating proportional height ({height:.1f}pt) using 16:9 aspect ratio"
-            )
-            request["createImage"]["elementProperties"]["size"] = {
-                "width": {"magnitude": width, "unit": "PT"},
-                "height": {"magnitude": height, "unit": "PT"},
-            }
-        # If neither width nor height specified, omit size - image uses natural dimensions
-
-        return request
-
-    def _build_table_request_generic(
-        self, object_id: str, slide_id: str, element: dict[str, Any]
-    ) -> list[dict[str, Any]]:
-        """Generic helper to build table creation requests with data population"""
-        pos = element["position"]
-        content = element["content"]
-
-        # Extract table data
-        headers = content.get("headers", [])
-        rows_data = content.get("rows", [])
-
-        # Calculate table dimensions
-        num_rows = len(rows_data) + (
-            1 if headers else 0
-        )  # Add 1 for headers if present
-        num_columns = max(
-            len(headers) if headers else 0,
-            max(len(row) for row in rows_data) if rows_data else 0,
-        )
-
-        if num_columns == 0 or num_rows == 0:
-            logger.warning("Table has no data, skipping creation")
-            return []
-
-        requests = []
-
-        # Create table request
-        create_table_request = {
-            "createTable": {
-                "objectId": object_id,
-                "elementProperties": {
-                    "pageObjectId": slide_id,
-                    "size": {
-                        "width": {"magnitude": pos["width"], "unit": "PT"},
-                        "height": {"magnitude": pos["height"], "unit": "PT"},
-                    },
-                    "transform": {
-                        "scaleX": 1,
-                        "scaleY": 1,
-                        "translateX": pos["x"],
-                        "translateY": pos["y"],
-                        "unit": "PT",
-                    },
-                },
-                "rows": num_rows,
-                "columns": num_columns,
-            }
-        }
-        requests.append(create_table_request)
-
-        # Populate table with data
-        current_row = 0
-
-        # Insert headers if present
-        if headers:
-            for col_index, header_text in enumerate(headers):
-                if col_index < num_columns and header_text:
-                    requests.append(
-                        {
-                            "insertText": {
-                                "objectId": object_id,
-                                "cellLocation": {
-                                    "rowIndex": current_row,
-                                    "columnIndex": col_index,
-                                },
-                                "text": str(header_text),
-                                "insertionIndex": 0,
-                            }
-                        }
-                    )
-            current_row += 1
-
-        # Insert row data
-        for row_index, row in enumerate(rows_data):
-            table_row_index = current_row + row_index
-            for col_index, cell_text in enumerate(row):
-                if col_index < num_columns and cell_text and table_row_index < num_rows:
-                    requests.append(
-                        {
-                            "insertText": {
-                                "objectId": object_id,
-                                "cellLocation": {
-                                    "rowIndex": table_row_index,
-                                    "columnIndex": col_index,
-                                },
-                                "text": str(cell_text),
-                                "insertionIndex": 0,
-                            }
-                        }
-                    )
-
-                # Add table styling based on style configuration
-        style = element.get("style", {})
-
-        # Add styling based on prompt rules
-        if style:
-            # Make first column bold if specified (prompt rule)
-            if style.get("firstColumnBold", False):
-                for row_idx in range(num_rows):
-                    requests.append(
-                        {
-                            "updateTextStyle": {
-                                "objectId": object_id,
-                                "cellLocation": {
-                                    "rowIndex": row_idx,
-                                    "columnIndex": 0,
-                                },
-                                "style": {"bold": True},
-                                "fields": "bold",
-                            }
-                        }
-                    )
-            # Add header row styling if headers are present
-            if headers and style.get("headerStyle"):
-                header_style = style["headerStyle"]
-                for col_index in range(len(headers)):
-                    if header_style.get("bold"):
-                        requests.append(
-                            {
-                                "updateTextStyle": {
-                                    "objectId": object_id,
-                                    "cellLocation": {
-                                        "rowIndex": 0,
-                                        "columnIndex": col_index,
-                                    },
-                                    "style": {"bold": True},
-                                    "fields": "bold",
-                                }
-                            }
-                        )
-
-                    if header_style.get("backgroundColor"):
-                        color_obj, alpha = self._parse_color_with_alpha(
-                            header_style["backgroundColor"]
-                        )
-                        if color_obj:
-                            requests.append(
-                                {
-                                    "updateTableCellProperties": {
-                                        "objectId": object_id,
-                                        "tableRange": {
-                                            "location": {
-                                                "rowIndex": 0,
-                                                "columnIndex": col_index,
-                                            },
-                                            "rowSpan": 1,
-                                            "columnSpan": 1,
-                                        },
-                                        "tableCellProperties": {
-                                            "tableCellBackgroundFill": {
-                                                "solidFill": {
-                                                    "color": color_obj,
-                                                    "alpha": alpha,
-                                                }
-                                            }
-                                        },
-                                        "fields": "tableCellBackgroundFill",
-                                    }
-                                }
-                            )
-
-        return requests
-
-    def _hex_to_rgb(self, hex_color: str) -> dict[str, float]:
-        """Convert hex color to RGB values (0-1 range)"""
-        # Remove # if present
-        hex_color = hex_color.lstrip("#")
-
-        # Handle 8-character hex (with alpha) by taking first 6 characters
-        if len(hex_color) == 8:
-            hex_color = hex_color[:6]
-
-        # Convert to RGB
-        try:
-            r = int(hex_color[0:2], 16) / 255.0
-            g = int(hex_color[2:4], 16) / 255.0
-            b = int(hex_color[4:6], 16) / 255.0
-            return {"red": r, "green": g, "blue": b}
-        except ValueError:
-            # Default to light pink if conversion fails
-            return {"red": 0.97, "green": 0.8, "blue": 0.8}
-
-    def update_text_formatting(
-        self,
-        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 with support for font and alignment parameters.
-
-        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
-        """
-        try:
-            import re
-
-            # First, replace the text content if needed
-            plain_text = formatted_text
-            # Remove bold markers
-            plain_text = re.sub(r"\*\*(.*?)\*\*", r"\1", plain_text)
-            # Remove italic markers
-            plain_text = re.sub(r"\*(.*?)\*", r"\1", plain_text)
-            # Remove code markers if present
-            plain_text = re.sub(r"`(.*?)`", r"\1", plain_text)
-
-            # Update the text content first if it has formatting markers
-            if plain_text != formatted_text:
-                update_text_request = {
-                    "deleteText": {"objectId": element_id, "textRange": {"type": "ALL"}}
-                }
-
-                insert_text_request = {
-                    "insertText": {
-                        "objectId": element_id,
-                        "insertionIndex": 0,
-                        "text": plain_text,
-                    }
-                }
-
-                # Execute text replacement
-                self.service.presentations().batchUpdate(
-                    presentationId=presentation_id,
-                    body={"requests": [update_text_request, insert_text_request]},
-                ).execute()
-
-            # Generate style requests
-            style_requests = []
-
-            # If font_size or font_family are specified, apply them to the specified range or entire text
-            if font_size is not None or font_family is not None:
-                style = {}
-                fields = []
-
-                if font_size is not None:
-                    style["fontSize"] = {"magnitude": font_size, "unit": "PT"}
-                    fields.append("fontSize")
-
-                if font_family is not None:
-                    style["fontFamily"] = font_family
-                    fields.append("fontFamily")
-
-                if style:
-                    text_range = {"type": "ALL"}
-                    if start_index is not None and end_index is not None:
-                        text_range = {
-                            "type": "FIXED_RANGE",
-                            "startIndex": start_index,
-                            "endIndex": end_index,
-                        }
-
-                    style_requests.append(
-                        {
-                            "updateTextStyle": {
-                                "objectId": element_id,
-                                "textRange": text_range,
-                                "style": style,
-                                "fields": ",".join(fields),
-                            }
-                        }
-                    )
-
-            # Handle text alignment (paragraph-level formatting)
-            if text_alignment is not None:
-                # Map alignment values to Google Slides API format
-                alignment_map = {
-                    "LEFT": "START",
-                    "CENTER": "CENTER",
-                    "RIGHT": "END",
-                    "JUSTIFY": "JUSTIFIED",
-                }
-
-                api_alignment = alignment_map.get(text_alignment.upper(), "START")
-                if api_alignment:
-                    text_range = {"type": "ALL"}
-                    if start_index is not None and end_index is not None:
-                        text_range = {
-                            "type": "FIXED_RANGE",
-                            "startIndex": start_index,
-                            "endIndex": end_index,
-                        }
-
-                    style_requests.append(
-                        {
-                            "updateParagraphStyle": {
-                                "objectId": element_id,
-                                "textRange": text_range,
-                                "style": {"alignment": api_alignment},
-                                "fields": "alignment",
-                            }
-                        }
-                    )
-
-            # Handle vertical alignment (content alignment for the entire text box)
-            if vertical_alignment is not None:
-                # Map vertical alignment values to Google Slides API format
-                valign_map = {"TOP": "TOP", "MIDDLE": "MIDDLE", "BOTTOM": "BOTTOM"}
-
-                api_valign = valign_map.get(vertical_alignment.upper(), "TOP")
-                if api_valign:
-                    style_requests.append(
-                        {
-                            "updateShapeProperties": {
-                                "objectId": element_id,
-                                "shapeProperties": {"contentAlignment": api_valign},
-                                "fields": "contentAlignment",
-                            }
-                        }
-                    )
-
-            # Process bold text formatting
-            bold_pattern = r"\*\*(.*?)\*\*"
-            bold_matches = list(re.finditer(bold_pattern, formatted_text))
-
-            text_offset = 0  # Track offset due to removed markers
-            for match in bold_matches:
-                content = match.group(1)
-                # Calculate position in plain text
-                start_pos = match.start() - text_offset
-                end_pos = start_pos + len(content)
-
-                style_requests.append(
-                    {
-                        "updateTextStyle": {
-                            "objectId": element_id,
-                            "textRange": {
-                                "type": "FIXED_RANGE",
-                                "startIndex": start_pos,
-                                "endIndex": end_pos,
-                            },
-                            "style": {"bold": True},
-                            "fields": "bold",
-                        }
-                    }
-                )
-
-                # Update offset (removed 4 characters: **)
-                text_offset += 4
-
-            # Process italic text formatting
-            italic_pattern = r"\*(.*?)\*"
-            italic_matches = list(re.finditer(italic_pattern, formatted_text))
-
-            text_offset = 0  # Reset offset for italic processing
-            for match in italic_matches:
-                content = match.group(1)
-                # Skip if this is part of a bold pattern
-                if any(
-                    bold_match.start() <= match.start() < bold_match.end()
-                    for bold_match in bold_matches
-                ):
-                    continue
-
-                start_pos = match.start() - text_offset
-                end_pos = start_pos + len(content)
-
-                style_requests.append(
-                    {
-                        "updateTextStyle": {
-                            "objectId": element_id,
-                            "textRange": {
-                                "type": "FIXED_RANGE",
-                                "startIndex": start_pos,
-                                "endIndex": end_pos,
-                            },
-                            "style": {"italic": True},
-                            "fields": "italic",
-                        }
-                    }
-                )
-
-                # Update offset (removed 2 characters: *)
-                text_offset += 2
-
-            # Process code text formatting
-            code_pattern = r"`(.*?)`"
-            code_matches = list(re.finditer(code_pattern, formatted_text))
-
-            text_offset = 0  # Reset offset for code processing
-            for match in code_matches:
-                content = match.group(1)
-                start_pos = match.start() - text_offset
-                end_pos = start_pos + len(content)
-
-                style_requests.append(
-                    {
-                        "updateTextStyle": {
-                            "objectId": element_id,
-                            "textRange": {
-                                "type": "FIXED_RANGE",
-                                "startIndex": start_pos,
-                                "endIndex": end_pos,
-                            },
-                            "style": {
-                                "fontFamily": "Courier New",
-                                "backgroundColor": {
-                                    "opaqueColor": {
-                                        "rgbColor": {
-                                            "red": 0.95,
-                                            "green": 0.95,
-                                            "blue": 0.95,
-                                        }
-                                    }
-                                },
-                            },
-                            "fields": "fontFamily,backgroundColor",
-                        }
-                    }
-                )
-
-                # Update offset (removed 2 characters: `)
-                text_offset += 2
-
-            # Execute all style requests
-            if style_requests:
-                logger.info(f"Applying {len(style_requests)} formatting requests")
-                response = (
-                    self.service.presentations()
-                    .batchUpdate(
-                        presentationId=presentation_id,
-                        body={"requests": style_requests},
-                    )
-                    .execute()
-                )
-
-                return {
-                    "presentationId": presentation_id,
-                    "elementId": element_id,
-                    "appliedFormats": {
-                        "fontSize": font_size,
-                        "fontFamily": font_family,
-                        "textAlignment": text_alignment,
-                        "verticalAlignment": vertical_alignment,
-                        "textRange": (
-                            {"startIndex": start_index, "endIndex": end_index}
-                            if start_index is not None and end_index is not None
-                            else "ALL"
-                        ),
-                    },
-                    "operation": "update_text_formatting",
-                    "result": "success",
-                }
-
-            return {"result": "no_formatting_applied"}
-
-        except Exception as e:
-            return self.handle_api_error("update_text_formatting", e)
-
-    def convert_template_zones_to_pt(
-        self, 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)
-        """
-        try:
-            return convert_template_zones(template_zones, target_unit="PT")
-        except Exception as e:
-            return self.handle_api_error("convert_template_zones_to_pt", e)
-
-    def _parse_color_with_alpha(
-        self, color_value: str | dict
-    ) -> tuple[dict | None, float]:
-        """Parse color value with alpha support for Google Slides API format.
-
-        Args:
-            color_value: Color as hex string (e.g., "#ffffff", "#ffffff80"), RGB dict, rgba() string, or theme color
-
-        Returns:
-            Tuple of (color_object, alpha_value) where alpha is 0.0-1.0
-        """
-        if not color_value:
-            return None, 1.0
-
-        alpha = 1.0  # Default to fully opaque
-
-        # Handle hex color strings
-        if isinstance(color_value, str):
-            if color_value.lower() == "white":
-                color_value = "#ffffff"
-            elif color_value.lower() == "black":
-                color_value = "#000000"
-
-            # Handle rgba() CSS format
-            if color_value.startswith("rgba("):
-                import re
-
-                # Parse rgba(r, g, b, a) format
-                match = re.match(
-                    r"rgba\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*,\s*([\d.]+)\s*\)",
-                    color_value,
-                )
-                if match:
-                    r = int(match.group(1)) / 255.0
-                    g = int(match.group(2)) / 255.0
-                    b = int(match.group(3)) / 255.0
-                    alpha = float(match.group(4))
-
-                    color_obj = {"rgbColor": {"red": r, "green": g, "blue": b}}
-                    return color_obj, alpha
-                else:
-                    logger.warning(f"Invalid rgba format: {color_value}")
-                    return None, 1.0
-
-            # Handle rgb() CSS format (no alpha)
-            elif color_value.startswith("rgb("):
-                import re
-
-                # Parse rgb(r, g, b) format
-                match = re.match(
-                    r"rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)", color_value
-                )
-                if match:
-                    r = int(match.group(1)) / 255.0
-                    g = int(match.group(2)) / 255.0
-                    b = int(match.group(3)) / 255.0
-
-                    color_obj = {"rgbColor": {"red": r, "green": g, "blue": b}}
-                    return color_obj, alpha
-                else:
-                    logger.warning(f"Invalid rgb format: {color_value}")
-                    return None, 1.0
-
-            elif color_value.startswith("#"):
-                # Convert hex to RGB
-                try:
-                    hex_color = color_value.lstrip("#")
-                    if len(hex_color) == 6:
-                        r = int(hex_color[0:2], 16) / 255.0
-                        g = int(hex_color[2:4], 16) / 255.0
-                        b = int(hex_color[4:6], 16) / 255.0
-
-                        color_obj = {"rgbColor": {"red": r, "green": g, "blue": b}}
-                        return color_obj, alpha
-                    elif len(hex_color) == 8:
-                        # Handle 8-character hex with alpha (RRGGBBAA)
-                        r = int(hex_color[0:2], 16) / 255.0
-                        g = int(hex_color[2:4], 16) / 255.0
-                        b = int(hex_color[4:6], 16) / 255.0
-                        alpha = int(hex_color[6:8], 16) / 255.0  # Extract alpha
-
-                        color_obj = {"rgbColor": {"red": r, "green": g, "blue": b}}
-                        return color_obj, alpha
-                except ValueError:
-                    logger.warning(f"Invalid hex color format: {color_value}")
-                    return None, 1.0
-
-        # Handle RGB dict format
-        elif isinstance(color_value, dict):
-            if "r" in color_value and "g" in color_value and "b" in color_value:
-                color_obj = {
-                    "rgbColor": {
-                        "red": color_value["r"] / 255.0,
-                        "green": color_value["g"] / 255.0,
-                        "blue": color_value["b"] / 255.0,
-                    }
-                }
-                alpha = color_value.get("a", 255) / 255.0  # Handle alpha if present
-                return color_obj, alpha
-            elif (
-                "red" in color_value
-                and "green" in color_value
-                and "blue" in color_value
-            ):
-                color_obj = {
-                    "rgbColor": {
-                        "red": color_value["red"],
-                        "green": color_value["green"],
-                        "blue": color_value["blue"],
-                    }
-                }
-                alpha = color_value.get("alpha", 1.0)  # Handle alpha if present
-                return color_obj, alpha
-
-        logger.warning(f"Unsupported color format: {color_value}")
-        return None, 1.0
+            return self.handle_api_error("embed_sheets_chart", e)