perf: lazy load heavy libraries to reduce memory usage

- Remove unused litellm and openai imports from sb_files_tool.py
- Lazy load PIL in sb_vision_tool.py (only when processing images)
- Lazy load numpy and google.genai in component_search_tool.py
- Lazy load Polar SDK in polar_service.py (only when payments used)
- Lazy load polar_sdk.webhooks in webhook handler

Estimated savings: ~48-75 MB per worker (~240-375 MB total with 5 workers)

Also: Update deploy tooltip text in thread-site-header.tsx

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: iamjr15

backend/agent/tools/component_search_tool.py

@@ -1,14 +1,10 @@
 import json
-import numpy as np
 from typing import List, Dict, Any, Optional
 from agentpress.tool import Tool, ToolResult, ToolSchema, SchemaType, XMLTagSchema, XMLNodeMapping
 from agentpress.thread_manager import ThreadManager
 from services.supabase import DBConnection
 from utils.logger import logger
 from utils.config import config
-# Google Generative AI (Gemini) SDK
-from google import genai
-from google.genai import types
 
 class ComponentSearchTool(Tool):
     """Tool for searching components using embedding-based semantic search.
@@ -22,19 +18,29 @@ def __init__(self, thread_manager: ThreadManager, app_type: str = 'web'):
         self.thread_manager = thread_manager
         self.db = DBConnection()
         self.app_type = app_type
+        self._client = None
+        self._client_initialized = False
         logger.info(f"🔍 ComponentSearchTool initialized with app_type: {app_type}")
 
-        # Initialize Gemini API client using centralized config
+    def _get_client(self):
+        """Lazy initialize the Gemini API client."""
+        if self._client_initialized:
+            return self._client
+
+        from google import genai  # Lazy load - only needed when search is used
+
         api_key = config.GOOGLE_API_KEY
         try:
             if api_key:
-                self.client = genai.Client(api_key=api_key)
+                self._client = genai.Client(api_key=api_key)
             else:
                 logger.debug("GOOGLE_API_KEY not set – skipping Gemini client init")
-                self.client = None
-        except Exception as api_err:  # pragma: no cover
+                self._client = None
+        except Exception as api_err:
             logger.warning(f"Failed to initialize Google GenAI client: {api_err}")
-            self.client = None
+            self._client = None
+        self._client_initialized = True
+        return self._client
 
     def get_schemas(self) -> Dict[str, List[ToolSchema]]:
         """Override base class to provide dynamic schemas based on app_type."""
@@ -174,35 +180,39 @@ def get_tool_schemas(self) -> Dict[str, List[ToolSchema]]:
     async def _generate_embedding(self, text: str) -> List[float]:
         """Generate embedding for the given text using Gemini."""
         try:
-            if not self.client:
+            from google.genai import types  # Lazy load - only needed for embedding
+            import numpy as np  # Lazy load - only needed for normalization
+
+            client = self._get_client()
+            if not client:
                 logger.error("Gemini client not initialized")
                 return []
-            
+
             # Use the latest Gemini embedding API
-            response = self.client.models.embed_content(
+            response = client.models.embed_content(
                 model='gemini-embedding-001',
                 contents=text,
                 config=types.EmbedContentConfig(
                     task_type="CODE_RETRIEVAL_QUERY",  # Optimized for code queries
                     output_dimensionality=1536
                 )
             )
-            
+
             if response and response.embeddings:
                 # Get the first (and only) embedding from the response
                 embedding_obj = response.embeddings[0]
                 embedding_values = embedding_obj.values
-                
+
                 # Normalize the embedding for 1536 dimensions (as per documentation)
                 # The 3072 dimension embedding is auto-normalized, but smaller ones need manual normalization
                 embedding_array = np.array(embedding_values)
                 normalized_embedding = embedding_array / np.linalg.norm(embedding_array)
-                
+
                 return normalized_embedding.tolist()
             else:
                 logger.error("No embeddings returned from Gemini API")
                 return []
-                
+
         except Exception as e:
             logger.error(f"Error generating embedding: {e}")
             return []

backend/agent/tools/sb_files_tool.py

@@ -7,8 +7,6 @@
 from utils.config import config
 import json
 import re
-import litellm
-import openai
 
 class SandboxFilesTool(SandboxToolsBase):
     """Tool for executing file system operations in a Daytona sandbox. All operations are performed relative to the workspace directory."""

backend/agent/tools/sb_vision_tool.py

@@ -3,7 +3,6 @@
 import mimetypes
 from typing import Optional, Tuple, Dict, List
 from io import BytesIO
-from PIL import Image
 from urllib.parse import urlparse
 from agentpress.tool import ToolResult, ToolSchema, SchemaType, XMLTagSchema, XMLNodeMapping
 from sandbox.tool_base import SandboxToolsBase
@@ -115,16 +114,18 @@ def get_tool_schemas(self) -> Dict[str, List[ToolSchema]]:
 
     def compress_image(self, image_bytes: bytes, mime_type: str, file_path: str) -> Tuple[bytes, str]:
         """Compress an image to reduce its size while maintaining reasonable quality.
-        
+
         Args:
             image_bytes: Original image bytes
             mime_type: MIME type of the image
             file_path: Path to the image file (for logging)
-            
+
         Returns:
             Tuple of (compressed_bytes, new_mime_type)
         """
         try:
+            from PIL import Image  # Lazy load - only needed when processing images
+
             # Open image from bytes
             img = Image.open(BytesIO(image_bytes))
 

backend/api/webhooks/polar.py

@@ -6,8 +6,6 @@
 from datetime import datetime, timedelta
 from typing import Dict, Any
 
-from polar_sdk.webhooks import validate_event, WebhookVerificationError
-
 from services.supabase import DBConnection
 from services.billing import invalidate_billing_cache
 from utils.logger import logger
@@ -237,6 +235,9 @@ async def handle_subscription_active(data: Dict[str, Any]):
 async def handle_polar_webhook(request: Request):
     """Handle Polar webhook events."""
     try:
+        # Lazy load - only needed when webhook is called
+        from polar_sdk.webhooks import validate_event, WebhookVerificationError
+
         # Get raw payload
         payload = await request.body()
 

backend/services/polar_service.py

@@ -3,7 +3,6 @@
 """
 
 from typing import Dict, Optional
-from polar_sdk import Polar
 
 from utils.config import config
 from utils.logger import logger
@@ -18,6 +17,8 @@ class PolarService:
     def __init__(self):
         self.access_token = config.POLAR_ACCESS_TOKEN
         self.organization_id = config.POLAR_ORGANIZATION_ID
+        self._client = None
+        self._client_initialized = False
 
         # Build product mapping from config
         self.PRODUCT_MAPPING = {
@@ -26,13 +27,23 @@ def __init__(self):
             'byok': config.POLAR_PRODUCT_ID_BYOK
         }
 
+    @property
+    def client(self):
+        """Lazy initialize the Polar client."""
+        if self._client_initialized:
+            return self._client
+
         if not self.access_token:
             logger.warning("POLAR_ACCESS_TOKEN not configured - payment processing will be unavailable")
-            self.client = None
+            self._client = None
         else:
-            self.client = Polar(access_token=self.access_token)
+            from polar_sdk import Polar  # Lazy load - only needed when payments are used
+            self._client = Polar(access_token=self.access_token)
             logger.info("Polar SDK initialized successfully")
 
+        self._client_initialized = True
+        return self._client
+
     def is_configured(self) -> bool:
         """Check if Polar is properly configured."""
         return self.client is not None

frontend/src/components/thread/thread-site-header.tsx

@@ -445,7 +445,7 @@ export function SiteHeader() {
                       <div className="p-4 space-y-3">
                         <h4 className="text-sm font-semibold text-white">Deploy your site</h4>
                         <p className="text-sm text-muted-foreground">
-                            Your app will be deployed to a .style.dev domain based on your project name.
+                            Your app will be deployed and you&apos;ll receive a live URL.
                           </p>
 
                         {/* Progress bar during deployment */}