aiecs 1.7.6__py3-none-any.whl → 1.7.17__py3-none-any.whl

aiecs/llm/clients/vertex_client.py

@@ -1,8 +1,10 @@
 import asyncio
+import json
 import logging
 import os
 import warnings
-from typing import Dict, Any, Optional, List, AsyncGenerator
+import hashlib
+from typing import Dict, Any, Optional, List, AsyncGenerator, Union
 import vertexai
 from vertexai.generative_models import (
     GenerativeModel,
@@ -14,6 +16,43 @@ from vertexai.generative_models import (
     Part,
 )
 
+logger = logging.getLogger(__name__)
+
+# Try to import CachedContent for prompt caching support
+# CachedContent API requires google-cloud-aiplatform >= 1.38.0
+# Reference: https://cloud.google.com/vertex-ai/generative-ai/docs/model-reference/cached-content
+CACHED_CONTENT_AVAILABLE = False
+CACHED_CONTENT_IMPORT_PATH = None
+CACHED_CONTENT_SDK_VERSION = None
+
+# Check SDK version
+try:
+    import google.cloud.aiplatform as aiplatform
+    CACHED_CONTENT_SDK_VERSION = getattr(aiplatform, '__version__', None)
+except ImportError:
+    pass
+
+# Try to import CachedContent for prompt caching support
+try:
+    from vertexai.preview import caching
+    if hasattr(caching, 'CachedContent'):
+        CACHED_CONTENT_AVAILABLE = True
+        CACHED_CONTENT_IMPORT_PATH = 'vertexai.preview.caching'
+    else:
+        # Module exists but CachedContent class not found
+        CACHED_CONTENT_AVAILABLE = False
+except ImportError:
+    try:
+        # Alternative import path for different SDK versions
+        from vertexai import caching
+        if hasattr(caching, 'CachedContent'):
+            CACHED_CONTENT_AVAILABLE = True
+            CACHED_CONTENT_IMPORT_PATH = 'vertexai.caching'
+        else:
+            CACHED_CONTENT_AVAILABLE = False
+    except ImportError:
+        CACHED_CONTENT_AVAILABLE = False
+
 from aiecs.llm.clients.base_client import (
     BaseLLMClient,
     LLMMessage,
@@ -147,17 +186,20 @@ def _build_safety_block_error(
     error_parts = [default_message]
     if block_reason:
         error_parts.append(f"Block reason: {block_reason}")
-    
-    blocked_categories = [
-        r.get("category", "UNKNOWN")
-        for r in safety_ratings
-        if r.get("blocked", False)
-    ]
+
+    # Safely extract blocked categories, handling potential non-dict elements
+    blocked_categories = []
+    for r in safety_ratings:
+        if isinstance(r, dict) and r.get("blocked", False):
+            blocked_categories.append(r.get("category", "UNKNOWN"))
     if blocked_categories:
         error_parts.append(f"Blocked categories: {', '.join(blocked_categories)}")
-    
+
     # Add severity/probability information
     for rating in safety_ratings:
+        # Skip non-dict elements
+        if not isinstance(rating, dict):
+            continue
         if rating.get("blocked"):
             if "severity" in rating:
                 error_parts.append(
@@ -193,6 +235,8 @@ class VertexAIClient(BaseLLMClient, GoogleFunctionCallingMixin):
             "part_counts": {},  # {part_count: frequency}
             "last_part_count": None,
         }
+        # Cache for CachedContent objects (key: content hash, value: cached_content_id)
+        self._cached_content_cache: Dict[str, str] = {}
 
     def _init_vertex_ai(self):
         """Lazy initialization of Vertex AI with proper authentication"""
@@ -230,14 +274,140 @@ class VertexAIClient(BaseLLMClient, GoogleFunctionCallingMixin):
             except Exception as e:
                 raise ProviderNotAvailableError(f"Failed to initialize Vertex AI: {str(e)}")
 
+    def _generate_content_hash(self, content: str) -> str:
+        """Generate a hash for content to use as cache key."""
+        return hashlib.md5(content.encode('utf-8')).hexdigest()
+
+    async def _create_or_get_cached_content(
+        self,
+        content: str,
+        model_name: str,
+        ttl_seconds: Optional[int] = None,
+    ) -> Optional[str]:
+        """
+        Create or get a CachedContent for the given content.
+        
+        This method implements Gemini's CachedContent API for prompt caching.
+        It preserves the existing cache_control mechanism for developer convenience.
+        
+        The method supports multiple Vertex AI SDK versions and gracefully falls back
+        to regular system_instruction if CachedContent API is unavailable.
+        
+        Args:
+            content: Content to cache (typically system instruction)
+            model_name: Model name to use for caching
+            ttl_seconds: Time to live in seconds (optional, defaults to 3600)
+            
+        Returns:
+            CachedContent resource name (e.g., "projects/.../cachedContents/...") or None if caching unavailable
+        """
+        if not CACHED_CONTENT_AVAILABLE:
+            # Provide version info if available
+            version_info = ""
+            if CACHED_CONTENT_SDK_VERSION:
+                version_info = f" (SDK version: {CACHED_CONTENT_SDK_VERSION})"
+            elif CACHED_CONTENT_IMPORT_PATH:
+                version_info = f" (import path '{CACHED_CONTENT_IMPORT_PATH}' available but CachedContent class not found)"
+            
+            self.logger.debug(
+                f"CachedContent API not available{version_info}, skipping cache creation. "
+                f"Requires google-cloud-aiplatform >=1.38.0"
+            )
+            return None
+        
+        if not content or not content.strip():
+            return None
+        
+        # Generate cache key
+        cache_key = self._generate_content_hash(content)
+        
+        # Check if we already have this cached
+        if cache_key in self._cached_content_cache:
+            cached_content_id = self._cached_content_cache[cache_key]
+            self.logger.debug(f"Using existing CachedContent: {cached_content_id}")
+            return cached_content_id
+        
+        try:
+            self._init_vertex_ai()
+            
+            # Build the content to cache (system instruction as Content)
+            # For CachedContent, we typically cache the system instruction
+            cached_content_obj = Content(
+                role="user",
+                parts=[Part.from_text(content)]
+            )
+            
+            # Try different API patterns based on SDK version
+            cached_content_id = None
+            
+            # Pattern 1: caching.CachedContent.create() (most common)
+            if hasattr(caching, 'CachedContent'):
+                try:
+                    cached_content = await asyncio.get_event_loop().run_in_executor(
+                        None,
+                        lambda: caching.CachedContent.create(
+                            model=model_name,
+                            contents=[cached_content_obj],
+                            ttl_seconds=ttl_seconds or 3600,  # Default 1 hour
+                        )
+                    )
+                    
+                    # Extract the resource name
+                    if hasattr(cached_content, 'name'):
+                        cached_content_id = cached_content.name
+                    elif hasattr(cached_content, 'resource_name'):
+                        cached_content_id = cached_content.resource_name
+                    else:
+                        cached_content_id = str(cached_content)
+                    
+                    if cached_content_id:
+                        # Store in cache
+                        self._cached_content_cache[cache_key] = cached_content_id
+                        self.logger.info(f"Created CachedContent for prompt caching: {cached_content_id}")
+                        return cached_content_id
+                        
+                except AttributeError as e:
+                    self.logger.debug(f"CachedContent.create() signature may differ: {str(e)}")
+                except Exception as e:
+                    self.logger.debug(f"Failed to create CachedContent using pattern 1: {str(e)}")
+            
+            # Pattern 2: Try alternative API patterns if Pattern 1 fails
+            # Note: Different SDK versions may have different APIs
+            # This is a fallback that allows graceful degradation
+            
+            # Build informative warning message with version info
+            version_info = ""
+            if CACHED_CONTENT_SDK_VERSION:
+                version_info = f" Current SDK version: {CACHED_CONTENT_SDK_VERSION}."
+            else:
+                version_info = " Unable to detect SDK version."
+            
+            required_version = ">=1.38.0"
+            upgrade_command = "pip install --upgrade 'google-cloud-aiplatform>=1.38.0'"
+            
+            self.logger.warning(
+                f"CachedContent API not available or incompatible with current SDK version.{version_info} "
+                f"Falling back to system_instruction (prompt caching disabled). "
+                f"To enable prompt caching, upgrade to google-cloud-aiplatform {required_version} or later: "
+                f"{upgrade_command}"
+            )
+            return None
+                
+        except Exception as e:
+            self.logger.warning(
+                f"Failed to create CachedContent (prompt caching disabled, using system_instruction): {str(e)}"
+            )
+            # Don't raise - allow fallback to regular generation without caching
+            return None
+
     def _convert_messages_to_contents(
         self, messages: List[LLMMessage]
     ) -> List[Content]:
         """
         Convert LLMMessage list to Vertex AI Content objects.
 
-        This properly handles multi-turn conversations instead of
-        string concatenation.
+        This properly handles multi-turn conversations including
+        function/tool responses for Vertex AI Function Calling.
 
         Args:
             messages: List of LLMMessage objects (system messages should be filtered out)
@@ -246,13 +416,77 @@ class VertexAIClient(BaseLLMClient, GoogleFunctionCallingMixin):
             List of Content objects for Vertex AI API
         """
         contents = []
+
         for msg in messages:
-            # Map role: Vertex AI uses "model" for assistant responses
-            role = "model" if msg.role == "assistant" else msg.role
-            contents.append(Content(
-                role=role,
-                parts=[Part.from_text(msg.content)]
-            ))
+            # Handle tool/function responses (role="tool")
+            if msg.role == "tool":
+                # Vertex AI expects function responses as user messages with FunctionResponse parts
+                # The tool_call_id maps to the function name
+                func_name = msg.tool_call_id or "unknown_function"
+
+                # Parse content as the function response
+                try:
+                    # Try to parse as JSON if it looks like JSON
+                    if msg.content and msg.content.strip().startswith('{'):
+                        response_data = json.loads(msg.content)
+                    else:
+                        response_data = {"result": msg.content}
+                except json.JSONDecodeError:
+                    response_data = {"result": msg.content}
+
+                # Create FunctionResponse part using Part.from_function_response
+                func_response_part = Part.from_function_response(
+                    name=func_name,
+                    response=response_data
+                )
+
+                contents.append(Content(
+                    role="user",  # Function responses are sent as "user" role in Vertex AI
+                    parts=[func_response_part]
+                ))
+
+            # Handle assistant messages with tool calls
+            elif msg.role == "assistant" and msg.tool_calls:
+                parts = []
+                if msg.content:
+                    parts.append(Part.from_text(msg.content))
+
+                for tool_call in msg.tool_calls:
+                    func = tool_call.get("function", {})
+                    func_name = func.get("name", "")
+                    func_args = func.get("arguments", "{}")
+
+                    # Parse arguments
+                    try:
+                        args_dict = json.loads(func_args) if isinstance(func_args, str) else func_args
+                    except json.JSONDecodeError:
+                        args_dict = {}
+
+                    # Create FunctionCall part using Part.from_dict
+                    # Note: Part.from_function_call() does NOT exist in Vertex AI SDK
+                    # Must use from_dict with function_call structure
+                    function_call_part = Part.from_dict({
+                        "function_call": {
+                            "name": func_name,
+                            "args": args_dict
+                        }
+                    })
+                    parts.append(function_call_part)
+
+                contents.append(Content(
+                    role="model",
+                    parts=parts
+                ))
+
+            # Handle regular messages (user, assistant without tool_calls)
+            else:
+                role = "model" if msg.role == "assistant" else msg.role
+                if msg.content:
+                    contents.append(Content(
+                        role=role,
+                        parts=[Part.from_text(msg.content)]
+                    ))
+
         return contents
 
     async def generate_text(
@@ -281,17 +515,37 @@ class VertexAIClient(BaseLLMClient, GoogleFunctionCallingMixin):
         try:
             # Extract system message from messages if present
             system_msg = None
+            system_cache_control = None
             user_messages = []
             for msg in messages:
                 if msg.role == "system":
                     system_msg = msg.content
+                    system_cache_control = msg.cache_control
                 else:
                     user_messages.append(msg)
 
             # Use explicit system_instruction parameter if provided, else use extracted system message
             final_system_instruction = system_instruction or system_msg
 
+            # Check if we should use CachedContent API for prompt caching
+            cached_content_id = None
+            if final_system_instruction and system_cache_control:
+                # Create or get CachedContent for the system instruction
+                # Extract TTL from cache_control if available (defaults to 3600 seconds)
+                ttl_seconds = getattr(system_cache_control, 'ttl_seconds', None) or 3600
+                cached_content_id = await self._create_or_get_cached_content(
+                    content=final_system_instruction,
+                    model_name=model_name,
+                    ttl_seconds=ttl_seconds,
+                )
+                if cached_content_id:
+                    self.logger.debug(f"Using CachedContent for prompt caching: {cached_content_id}")
+                    # When using CachedContent, we don't pass system_instruction to GenerativeModel
+                    # Instead, we'll pass cached_content_id to generate_content
+                    final_system_instruction = None
+
             # Initialize model WITH system instruction for prompt caching support
+            # Note: If using CachedContent, system_instruction will be None
             model_instance = GenerativeModel(
                 model_name,
                 system_instruction=final_system_instruction
@@ -362,13 +616,18 @@ class VertexAIClient(BaseLLMClient, GoogleFunctionCallingMixin):
                 "safety_settings": safety_settings,
             }
             
+            # Add cached_content if using CachedContent API for prompt caching
+            if cached_content_id:
+                api_params["cached_content"] = cached_content_id
+                self.logger.debug(f"Added cached_content to API params: {cached_content_id}")
+            
             # Add tools if available
             if tools_for_api:
                 api_params["tools"] = tools_for_api
             
-            # Add any additional kwargs (but exclude tools/safety_settings to avoid conflicts)
+            # Add any additional kwargs (but exclude tools/safety_settings/cached_content to avoid conflicts)
             for key, value in kwargs.items():
-                if key not in ["tools", "safety_settings"]:
+                if key not in ["tools", "safety_settings", "cached_content"]:
                     api_params[key] = value
             
             response = await asyncio.get_event_loop().run_in_executor(
@@ -553,7 +812,9 @@ class VertexAIClient(BaseLLMClient, GoogleFunctionCallingMixin):
 
             # Vertex AI doesn't provide detailed token usage in the response
             # Use estimation method as fallback
-            input_tokens = self._count_tokens_estimate(prompt)
+            # Estimate input tokens from messages content
+            prompt_text = " ".join(msg.content for msg in messages if msg.content)
+            input_tokens = self._count_tokens_estimate(prompt_text)
             output_tokens = self._count_tokens_estimate(content)
             tokens_used = input_tokens + output_tokens
 
@@ -608,7 +869,9 @@ class VertexAIClient(BaseLLMClient, GoogleFunctionCallingMixin):
             ):
                 self.logger.warning(f"Vertex AI response issue: {str(e)}")
                 # Return a response indicating the issue
-                estimated_prompt_tokens = self._count_tokens_estimate(prompt)
+                # Estimate prompt tokens from messages content
+                prompt_text = " ".join(msg.content for msg in messages if msg.content)
+                estimated_prompt_tokens = self._count_tokens_estimate(prompt_text)
                 return LLMResponse(
                     content="[Response unavailable due to content processing issues or safety filters]",
                     provider=self.provider_name,
@@ -664,17 +927,37 @@ class VertexAIClient(BaseLLMClient, GoogleFunctionCallingMixin):
         try:
             # Extract system message from messages if present
             system_msg = None
+            system_cache_control = None
             user_messages = []
             for msg in messages:
                 if msg.role == "system":
                     system_msg = msg.content
+                    system_cache_control = msg.cache_control
                 else:
                     user_messages.append(msg)
 
             # Use explicit system_instruction parameter if provided, else use extracted system message
             final_system_instruction = system_instruction or system_msg
 
+            # Check if we should use CachedContent API for prompt caching
+            cached_content_id = None
+            if final_system_instruction and system_cache_control:
+                # Create or get CachedContent for the system instruction
+                # Extract TTL from cache_control if available (defaults to 3600 seconds)
+                ttl_seconds = getattr(system_cache_control, 'ttl_seconds', None) or 3600
+                cached_content_id = await self._create_or_get_cached_content(
+                    content=final_system_instruction,
+                    model_name=model_name,
+                    ttl_seconds=ttl_seconds,
+                )
+                if cached_content_id:
+                    self.logger.debug(f"Using CachedContent for prompt caching in streaming: {cached_content_id}")
+                    # When using CachedContent, we don't pass system_instruction to GenerativeModel
+                    # Instead, we'll pass cached_content_id to generate_content
+                    final_system_instruction = None
+
             # Initialize model WITH system instruction for prompt caching support
+            # Note: If using CachedContent, system_instruction will be None
             model_instance = GenerativeModel(
                 model_name,
                 system_instruction=final_system_instruction
@@ -738,6 +1021,12 @@ class VertexAIClient(BaseLLMClient, GoogleFunctionCallingMixin):
             # Use mixin method for Function Calling support
             from aiecs.llm.clients.openai_compatible_mixin import StreamChunk
             
+            # Add cached_content to kwargs if using CachedContent API
+            stream_kwargs = kwargs.copy()
+            if cached_content_id:
+                stream_kwargs["cached_content"] = cached_content_id
+                self.logger.debug(f"Added cached_content to streaming API params: {cached_content_id}")
+            
             async for chunk in self._stream_text_with_function_calling(
                 model_instance=model_instance,
                 contents=contents,
@@ -745,7 +1034,7 @@ class VertexAIClient(BaseLLMClient, GoogleFunctionCallingMixin):
                 safety_settings=safety_settings,
                 tools=tools_for_api,
                 return_chunks=return_chunks,
-                **kwargs,
+                **stream_kwargs,
             ):
                 # Yield chunk (can be str or StreamChunk)
                 yield chunk

aiecs/main.py

@@ -142,7 +142,7 @@ async def lifespan(app: FastAPI):
 app = FastAPI(
     title="AIECS - AI Execute Services",
     description="Middleware service for AI-powered task execution and tool orchestration",
-    version="1.7.6",
+    version="1.7.17",
     lifespan=lifespan,
 )
 
@@ -164,7 +164,7 @@ socket_app = socketio.ASGIApp(sio, other_asgi_app=app)
 @app.get("/health")
 async def health_check():
     """Health check endpoint"""
-    return {"status": "healthy", "service": "aiecs", "version": "1.7.6"}
+    return {"status": "healthy", "service": "aiecs", "version": "1.7.17"}
 
 
 # Metrics health check endpoint

aiecs/tools/docs/document_creator_tool.py

@@ -55,6 +55,8 @@ class DocumentFormat(str, Enum):
     PLAIN_TEXT = "txt"
     JSON = "json"
     XML = "xml"
+    PPTX = "pptx"
+    PPT = "ppt"
 
 
 class TemplateType(str, Enum):
@@ -175,6 +177,9 @@ class DocumentCreatorTool(BaseTool):
         # Initialize templates
         self._init_templates()
 
+        # Initialize office tool for PPTX/DOCX creation
+        self._init_office_tool()
+
         # Initialize document tracking
         self._documents_created: List[Any] = []
 
@@ -197,6 +202,17 @@ class DocumentCreatorTool(BaseTool):
             TemplateType.INVOICE: self._get_invoice_template(),
         }
 
+    def _init_office_tool(self):
+        """Initialize office tool for PPTX/DOCX creation"""
+        try:
+            from aiecs.tools.task_tools.office_tool import OfficeTool
+
+            self.office_tool = OfficeTool()
+            self.logger.info("OfficeTool initialized successfully for PPTX/DOCX support")
+        except ImportError:
+            self.logger.warning("OfficeTool not available, PPTX/DOCX creation will be limited")
+            self.office_tool = None
+
     # Schema definitions
     class Create_documentSchema(BaseModel):
         """Schema for create_document operation"""
@@ -943,7 +959,7 @@ class DocumentCreatorTool(BaseTool):
                 "questions",
                 "contact_info",
             ],
-            "supported_formats": ["markdown", "html"],
+            "supported_formats": ["markdown", "html", "pptx"],
             "style_presets": ["presentation", "modern", "colorful"],
         }
 
@@ -1062,7 +1078,11 @@ class DocumentCreatorTool(BaseTool):
     ) -> str:
         """Generate output path for document"""
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"{document_type}_{timestamp}_{document_id[:8]}.{output_format.value}"
+        # Handle PPT format - use pptx extension
+        file_extension = output_format.value
+        if output_format == DocumentFormat.PPT:
+            file_extension = "pptx"  # PPT format uses PPTX extension
+        filename = f"{document_type}_{timestamp}_{document_id[:8]}.{file_extension}"
         return os.path.join(self.config.output_dir, filename)
 
     def _process_metadata(self, metadata: Dict[str, Any], output_format: DocumentFormat) -> Dict[str, Any]:
@@ -1175,11 +1195,130 @@ class DocumentCreatorTool(BaseTool):
         elif output_format == DocumentFormat.JSON:
             with open(output_path, "w", encoding="utf-8") as f:
                 json.dump({"content": content}, f, indent=2, ensure_ascii=False)
+        elif output_format in [DocumentFormat.PPTX, DocumentFormat.PPT]:
+            # Use office_tool to create PPTX file
+            self._write_pptx_file(output_path, content)
+        elif output_format == DocumentFormat.DOCX:
+            # Use office_tool to create DOCX file
+            self._write_docx_file(output_path, content)
         else:
             # For other formats, write as text for now
             with open(output_path, "w", encoding="utf-8") as f:
                 f.write(content)
 
+    def _write_pptx_file(self, output_path: str, content: str):
+        """Write content to PPTX file using office_tool"""
+        if not self.office_tool:
+            raise DocumentCreationError("OfficeTool not available. Cannot create PPTX files.")
+
+        try:
+            # Parse content to extract slides
+            # Slides are separated by "---" or slide markers like "## Slide X:"
+            slides = self._parse_content_to_slides(content)
+
+            # Use office_tool to create PPTX
+            result = self.office_tool.write_pptx(
+                slides=slides,
+                output_path=output_path,
+                image_path=None,  # Can be enhanced to extract image paths from metadata
+            )
+
+            if not result.get("success"):
+                raise DocumentCreationError(f"Failed to create PPTX file: {result}")
+
+            self.logger.info(f"PPTX file created successfully: {output_path}")
+
+        except Exception as e:
+            raise DocumentCreationError(f"Failed to write PPTX file: {str(e)}")
+
+    def _write_docx_file(self, output_path: str, content: str):
+        """Write content to DOCX file using office_tool"""
+        if not self.office_tool:
+            raise DocumentCreationError("OfficeTool not available. Cannot create DOCX files.")
+
+        try:
+            # Use office_tool to create DOCX
+            result = self.office_tool.write_docx(
+                text=content,
+                output_path=output_path,
+                table_data=None,  # Can be enhanced to extract tables from content
+            )
+
+            if not result.get("success"):
+                raise DocumentCreationError(f"Failed to create DOCX file: {result}")
+
+            self.logger.info(f"DOCX file created successfully: {output_path}")
+
+        except Exception as e:
+            raise DocumentCreationError(f"Failed to write DOCX file: {str(e)}")
+
+    def _parse_content_to_slides(self, content: str) -> List[str]:
+        """Parse content string into list of slide contents
+        
+        Supports multiple slide separation formats:
+        - "---" separator (markdown style)
+        - "## Slide X:" headers
+        - Empty lines between slides
+        """
+        slides = []
+        
+        # Split by "---" separator (common in markdown presentations)
+        if "---" in content:
+            parts = content.split("---")
+            for part in parts:
+                part = part.strip()
+                if part:
+                    # Remove slide headers like "## Slide X: Title"
+                    lines = part.split("\n")
+                    cleaned_lines = []
+                    for line in lines:
+                        # Skip slide headers
+                        if line.strip().startswith("## Slide") and ":" in line:
+                            continue
+                        cleaned_lines.append(line)
+                    slide_content = "\n".join(cleaned_lines).strip()
+                    if slide_content:
+                        slides.append(slide_content)
+        else:
+            # Try to split by "## Slide" headers
+            if "## Slide" in content:
+                parts = content.split("## Slide")
+                for i, part in enumerate(parts):
+                    if i == 0:
+                        # First part might be title slide
+                        part = part.strip()
+                        if part:
+                            slides.append(part)
+                    else:
+                        # Extract content after "Slide X: Title"
+                        lines = part.split("\n", 1)
+                        if len(lines) > 1:
+                            slide_content = lines[1].strip()
+                            if slide_content:
+                                slides.append(slide_content)
+            else:
+                # Fallback: split by double newlines (paragraph breaks)
+                parts = content.split("\n\n")
+                current_slide = []
+                for part in parts:
+                    part = part.strip()
+                    if part:
+                        # If it's a header, start a new slide
+                        if part.startswith("#"):
+                            if current_slide:
+                                slides.append("\n".join(current_slide))
+                                current_slide = []
+                        current_slide.append(part)
+                
+                if current_slide:
+                    slides.append("\n".join(current_slide))
+
+        # If no slides found, create a single slide with all content
+        if not slides:
+            slides = [content.strip()] if content.strip() else [""]
+
+        return slides
+
     def _process_template_variables(self, template_content: str, variables: Dict[str, Any]) -> str:
         """Process template variables in content"""
         result = template_content
@@ -1282,6 +1421,8 @@ class DocumentCreatorTool(BaseTool):
             ".tex": DocumentFormat.LATEX,
             ".docx": DocumentFormat.DOCX,
             ".pdf": DocumentFormat.PDF,
+            ".pptx": DocumentFormat.PPTX,
+            ".ppt": DocumentFormat.PPT,
         }
         return format_map.get(ext, DocumentFormat.PLAIN_TEXT)