Upload 5 files

main.py

@@ -0,0 +1,338 @@
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+from fastapi.staticfiles import StaticFiles
+from pydantic import HttpUrl
+from scraper import scrape_page
+from summarizer import quick_summarize
+from rich_card_builder import build_rich_card
+import asyncio
+from urllib.parse import urlparse
+import logging
+import http.client
+import json
+from dotenv import load_dotenv
+import os
+import google.generativeai as genai
+from typing import Optional, List, Dict
+
+# Load environment variables
+load_dotenv()
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+app = FastAPI(title="Website Scraper API (Enhanced for RCS)")
+
+# Mount static files
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# Set up Jinja2 templates
+templates = Jinja2Templates(directory="templates")
+
+# Sample rich cards for testing
+SAMPLE_RICH_CARDS = [
+    {
+        "title": "Summer Collection 2025",
+        "text": "Discover vibrant summer styles at Pantaloons.",
+        "media": "https://example.com/summer.jpg",
+        "url": "https://example.com/summer",
+        "buttons": [
+            {"type": "weburl", "title": "View Now", "payload": "https://example.com/summer"},
+            {"type": "postback", "title": "Learn More", "payload": "learn_more_1"}
+        ],
+        "quickReplies": [
+            {"type": "postback", "title": "Show Similar", "payload": "similar_content_1"},
+            {"type": "call", "title": "Contact Support", "payload": "+12345678901"}
+        ]
+    },
+    {
+        "title": "Yu Collection",
+        "text": "Explore trendy youth fashion with Yu Collection.",
+        "media": "https://example.com/yu.jpg",
+        "url": "https://example.com/yu_collection",
+        "buttons": [
+            {"type": "weburl", "title": "View Now", "payload": "https://example.com/yu_collection"},
+            {"type": "postback", "title": "Learn More", "payload": "learn_more_2"}
+        ],
+        "quickReplies": [
+            {"type": "postback", "title": "Show Similar", "payload": "similar_content_2"},
+            {"type": "call", "title": "Contact Support", "payload": "+12345678901"}
+        ]
+    }
+]
+
+async def generate_dynamic_buttons(title: str, description: str, url: str, next_interaction: str = None) -> List[Dict]:
+    """Generate dynamic quick reply buttons for the next interaction using Gemini-1.5 Flash."""
+    try:
+        # Validate inputs
+        title = title.strip() if title and title.strip() else "News Summary"
+        description = description.strip() if description and description.strip() else "Explore news and insights."
+        url = url.strip() if url and url.strip() else "https://example.com"
+        
+        logging.info(f"Generating buttons for: title={title}, description={description[:30]}..., url={url}")
+
+        # Get Gemini API key
+        api_key = os.getenv("GEMINI_API_KEY")
+        if not api_key:
+            logging.error("Gemini API key not found. Please set GEMINI_API_KEY in .env file.")
+            return [{"type": "postback", "title": "Explore More", "payload": f"goto_{next_interaction}", "execute": next_interaction}] if next_interaction else []
+
+        # Configure Gemini client
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel('gemini-1.5-flash')
+
+        # Combine inputs (no chunking, as input is small)
+        input_text = f"Title: {title}\nDescription: {description}\nURL: {url}"
+        input_text = input_text[:500]  # Truncate to 500 chars to stay within limits
+
+        # Optimized prompt
+        prompt = (
+            f"Based on the following content for the next interaction, suggest up to two concise (3-8 words) quick reply button titles that are action-oriented and invite the user to explore this content. The buttons should be engaging, relevant to the content, and avoid generic terms like 'Show Next'. Return the titles as a JSON array of strings.\n\n"
+            f"{input_text}\n\n"
+            f"Example output: [\"Discover Yu Collection\", \"Shop Youth Styles\"]\n"
+            f"Return only the JSON array, no markdown or extra text."
+        )
+
+        # Retry mechanism for API calls
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                response = await model.generate_content_async(prompt)
+                raw_content = response.text.strip()
+                logging.info(f"Gemini response: {raw_content}")
+
+                # Remove markdown code block markers if present
+                raw_content = raw_content.strip('```json').strip('```').strip()
+
+                # Parse response
+                button_titles = json.loads(raw_content)
+                if not isinstance(button_titles, list) or not all(isinstance(t, str) for t in button_titles):
+                    logging.warning(f"Invalid Gemini response format: {raw_content}")
+                    raise ValueError("Response is not a list of strings")
+                
+                # Filter valid button titles
+                valid_buttons = [t.strip() for t in button_titles if t.strip() and 3 <= len(t.strip().split()) <= 8]
+                if not valid_buttons:
+                    logging.warning("No valid button titles in response")
+                    raise ValueError("No valid button titles")
+
+                # Create quick replies
+                quick_replies = [
+                    {
+                        "type": "postback",
+                        "title": title[:20],  # Ensure concise title
+                        "payload": f"goto_{next_interaction}_{i}",
+                        "execute": next_interaction
+                    }
+                    for i, title in enumerate(valid_buttons[:2])
+                ]
+                logging.info(f"Generated quick replies: {quick_replies}")
+                return quick_replies
+
+            except Exception as e:
+                logging.warning(f"Attempt {attempt + 1} failed: {str(e)}")
+                if attempt < max_retries - 1:
+                    await asyncio.sleep(1)  # Wait before retrying
+                continue
+
+        # Fallback if all retries fail
+        logging.error("All retries failed for button generation")
+        return [{"type": "postback", "title": "Explore More", "payload": f"goto_{next_interaction}", "execute": next_interaction}] if next_interaction else []
+
+    except Exception as e:
+        logging.error(f"Error generating dynamic buttons: {str(e)}")
+        return [{"type": "postback", "title": "Explore More", "payload": f"goto_{next_interaction}", "execute": next_interaction}] if next_interaction else []
+
+async def create_nativemsg_bot(rich_cards: List[Dict], url: str, bot_name: str, api_token: str) -> Dict:
+    """Create a bot on NativeMSG with connected interactions based on rich cards."""
+    try:
+        # Validate API token
+        if not api_token:
+            logging.error("NativeMSG API token not provided and not found in .env file.")
+            raise ValueError("NativeMSG API token is required.")
+
+        # Use provided bot name or default to dynamic name
+        final_bot_name = bot_name or f"Bot for {urlparse(url).netloc}"
+
+        # Prepare bot payload
+        interactions = []
+
+        for idx, card in enumerate(rich_cards, 1):
+            # Determine the next interaction and next card (if any)
+            next_interaction = f"Interaction #{idx + 1}" if idx < len(rich_cards) else None
+            next_card = rich_cards[idx] if idx < len(rich_cards) else None
+
+            # Get buttons from current card
+            buttons = card.get("buttons", [])
+
+            # Generate dynamic quick replies based on *next* card
+            dynamic_quick_replies = []
+            if next_card:
+                dynamic_quick_replies = await generate_dynamic_buttons(
+                    title=next_card.get("title", "News Summary"),
+                    description=next_card.get("text", "Explore news and insights."),
+                    url=next_card.get("url", ""),
+                    next_interaction=next_interaction
+                )
+
+            # Define quick replies
+            quick_replies = dynamic_quick_replies + [
+                {
+                    "type": "call",
+                    "title": "Contact Support",
+                    "payload": "+12345678901"
+                }
+            ]
+
+            # Build message for current card
+            message = {
+                "text": f"{card['title']}\n\n{card['text']}",
+                "mediaType": "image",
+                "media": card.get("media", "") or "https://example.com/placeholder.jpg",
+                "richCard": {
+                    "cardOrientation": "VERTICAL",
+                    "mediaHeight": "MEDIUM"
+                },
+                "buttons": buttons,
+                "quickReplies": quick_replies
+            }
+
+            # Build interaction
+            interaction = {
+                "name": f"Interaction #{idx}",
+                "intents": ["show_content", f"content_{idx}"],
+                "actions": [
+                    {
+                        "send": {
+                            "message": message
+                        },
+                        "type": "RichCard",
+                        "name": f"Send Rich Card #{idx}"
+                    }
+                ]
+            }
+            interactions.append(interaction)
+
+        # Add welcome interaction
+        welcome_message = {
+            "text": f"Welcome to the {urlparse(url).netloc} RCS Bot! Explore the latest content.",
+            "richCard": {
+                "cardOrientation": "VERTICAL",
+                "mediaHeight": "MEDIUM"
+            },
+            "quickReplies": [
+                {
+                    "type": "postback",
+                    "title": "Start Exploring",
+                    "payload": "start_exploring",
+                    "execute": "Interaction #1"
+                }
+            ]
+        }
+        welcome_interaction = {
+            "name": "Welcome Interaction",
+            "intents": ["start", "welcome"],
+            "actions": [
+                {
+                    "send": {
+                        "message": welcome_message
+                    },
+                    "type": "RichCard",
+                    "name": "Send Welcome Message"
+                }
+            ]
+        }
+        interactions.insert(0, welcome_interaction)
+
+        payload = {
+            "name": final_bot_name,
+            "interactions": interactions
+        }
+
+        # Log the payload for debugging
+        logging.info(f"NativeMSG bot payload: {json.dumps(payload, indent=2)}")
+
+        # Send request to NativeMSG API
+        connection = http.client.HTTPSConnection("api.nativemsg.com")
+        headers = {
+            "Authorization": f"Bearer {api_token}",
+            "Content-Type": "application/json"
+        }
+        connection.request("POST", "/v1/bots", json.dumps(payload), headers)
+        response = connection.getresponse()
+        response_data = response.read().decode('utf-8')
+
+        logging.info(f"NativeMSG bot creation response: Status {response.status}, Data: {response_data}")
+
+        if response.status != 200:
+            logging.error(f"Failed to create bot: {response_data}")
+            raise HTTPException(status_code=500, detail=f"Failed to create bot: {response_data}")
+
+        return json.loads(response_data)
+
+    except Exception as e:
+        logging.error(f"Error creating NativeMSG bot: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Failed to create bot: {str(e)}")
+
+@app.get("/scrape")
+async def crawl_website(
+    url: HttpUrl,
+    use_sample: bool = False,
+    bot_name: Optional[str] = None,
+    nativemsg_token: Optional[str] = None
+):
+    """Crawl a website or use sample data, generate rich cards, and create a NativeMSG bot."""
+    try:
+        # Determine API token
+        api_token = nativemsg_token or os.getenv("NATIVEMSG_API_TOKEN")
+
+        if use_sample:
+            results = SAMPLE_RICH_CARDS
+        else:
+            visited = set()
+            to_visit = {str(url)}
+            base_domain = urlparse(str(url)).netloc
+            results = []
+
+            while to_visit and len(visited) < 20:  # Limited to 10 for demo
+                current_url = to_visit.pop()
+                if current_url in visited:
+                    continue
+                visited.add(current_url)
+
+                logging.info(f"Scraping page: {current_url}")
+                page_data, new_links = await scrape_page(current_url, visited, base_domain)
+                if page_data:
+                    logging.info(f"Scraped data: {page_data}")
+                    summary = await quick_summarize(page_data["text"], page_data["url"])
+                    rich_card = build_rich_card(page_data, summary)
+                    rich_card["title"] = summary.get("title", "News Summary")
+                    rich_card["url"] = page_data.get("url", str(url))
+                    results.append(rich_card)
+
+                to_visit.update(new_links)
+                await asyncio.sleep(0.5)
+
+            if not results:
+                logging.error("No rich cards generated from scraping.")
+                raise HTTPException(status_code=400, detail="No content scraped from the provided URL.")
+
+        # Create NativeMSG bot with the rich cards
+        bot_response = await create_nativemsg_bot(results, str(url), bot_name, api_token)
+
+        logging.info(f"Final response: {results}, Bot: {bot_response}")
+        return {"rich_cards": results, "bot_response": bot_response}
+
+    except Exception as e:
+        logging.error(f"Scraping or bot creation failed: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Scraping or bot creation failed: {str(e)}")
+
+@app.get("/", response_class=HTMLResponse)
+async def serve_home(request: Request):
+    """Serve the frontend HTML page."""
+    return templates.TemplateResponse("index.html", {"request": request})
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8001)

rich_card_builder.py

@@ -0,0 +1,71 @@
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+def select_relevant_image(images: list, text: str) -> str:
+    """Select a contextually relevant image from the list based on text."""
+    if not images:
+        logging.info("No images available, using empty media URL.")
+        return ""
+    
+    # Prioritize images that are likely content-related (avoid logos, icons)
+    for img in images:
+        if not any(keyword in img.lower() for keyword in ["logo", "icon", "banner", "ad"]):
+            logging.info(f"Selected image: {img}")
+            return img
+    
+    # Fallback to first image if no clear content image
+    logging.info(f"No content image found, using first image: {images[0]}")
+    return images[0]
+
+def build_rich_card(scraped_data: dict, summary: dict) -> dict:
+    """Build the rich card JSON using only scraped data and summary."""
+    logging.info(f"Building rich card with scraped_data: {scraped_data}, summary: {summary}")
+    
+    # Select relevant image
+    media_url = select_relevant_image(scraped_data.get("images", []), scraped_data.get("text", ""))
+    
+    # Use scraped URL
+    page_url = scraped_data.get("url", "")
+    
+    # Use summary description
+    description = summary.get("description", "Explore news and insights.")
+    
+    rich_card = {
+        "targets": [{"ids": [1368], "targetType": "humans"}],
+        "text": description,
+        "mediaType": "image",
+        "media": media_url,
+        "buttons": [
+            {
+                "type": "weburl",
+                "title": "View Now",
+                "payload": page_url
+            },
+            {
+                "type": "postback",
+                "title": "Learn More",
+                "payload": "learn_more",
+                "execute": None
+            }
+        ],
+        "quickReplies": [
+            {
+                "type": "postback",
+                "title": "Show Similar",
+                "payload": "similar_content"
+            },
+            {
+                "type": "call",
+                "title": "Contact Support",
+                "payload": "+12345678901"
+            }
+        ],
+        "richCard": {
+            "cardOrientation": "VERTICAL",
+            "mediaHeight": "MEDIUM"
+        }
+    }
+    logging.info(f"Generated rich card: {rich_card}")
+    return rich_card

scraper.py

@@ -0,0 +1,73 @@
+from playwright.async_api import async_playwright
+from urllib.parse import urljoin, urlparse
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+async def scrape_page(url: str, visited: set, base_domain: str) -> tuple[dict, set]:
+    """Scrape a single page for text, images, and links using Playwright."""
+    try:
+        async with async_playwright() as p:
+            browser = await p.chromium.launch(headless=True)
+            context = await browser.new_context(
+                user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/118.0.0.0 Safari/537.36",
+                viewport={"width": 1280, "height": 720}
+            )
+            page = await context.new_page()
+            await page.goto(url, wait_until="networkidle", timeout=30000)
+            await page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
+            await page.wait_for_timeout(2000)
+            
+            # Extract text content
+            text_content = await page.evaluate("document.body.innerText")
+            text_content = ' '.join(text_content.split()) if text_content else ""
+            
+            # Extract images (only JPEG, PNG, WebP, exclude data URLs and SVGs)
+            images = await page.evaluate(
+                """() => {
+                    const validExtensions = ['.jpg', '.jpeg', '.png', '.webp'];
+                    const imgElements = document.querySelectorAll('img');
+                    const imgUrls = new Set();
+                    imgElements.forEach(img => {
+                        const src = img.src || '';
+                        const dataSrc = img.dataset.src || '';
+                        const srcset = img.srcset || '';
+                        // Check src
+                        if (src && !src.startsWith('data:') && validExtensions.some(ext => src.toLowerCase().endsWith(ext))) {
+                            imgUrls.add(src);
+                        }
+                        // Check data-src
+                        if (dataSrc && !dataSrc.startsWith('data:') && validExtensions.some(ext => dataSrc.toLowerCase().endsWith(ext))) {
+                            imgUrls.add(dataSrc);
+                        }
+                        // Check srcset
+                        if (srcset) {
+                            srcset.split(',').forEach(src => {
+                                const url = src.trim().split(' ')[0];
+                                if (url && !url.startsWith('data:') && validExtensions.some(ext => url.toLowerCase().endsWith(ext))) {
+                                    imgUrls.add(url);
+                                }
+                            });
+                        }
+                    });
+                    return Array.from(imgUrls);
+                }"""
+            )
+            images = [urljoin(url, img) for img in images if img]
+            
+            # Extract links
+            links = await page.evaluate("Array.from(document.querySelectorAll('a')).map(a => a.href)")
+            links = set(urljoin(url, link) for link in links 
+                        if urlparse(urljoin(url, link)).netloc == base_domain 
+                        and urljoin(url, link) not in visited)
+            
+            await browser.close()
+        
+        page_data = {"url": url, "text": text_content, "images": images}
+        logging.info(f"Scraped data: url={url}, text_length={len(text_content)}, images={images}")
+        return page_data, links
+    
+    except Exception as e:
+        logging.error(f"Error scraping {url}: {e}")
+        return {}, set()

summarizer.py

@@ -0,0 +1,205 @@
+import os
+import re
+from typing import Dict, Optional
+import google.generativeai as genai
+import logging
+from dotenv import load_dotenv
+from urllib.parse import urlparse
+from cachetools import TTLCache
+
+# Load environment variables
+load_dotenv()
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# In-memory cache: 1000 items, 1-hour TTL
+cache = TTLCache(maxsize=1000, ttl=3600)
+
+async def summarize_text(text: str, url: str = "") -> Dict[str, str]:
+    """Summarize text into a title and description using Gemini-1.5 Flash."""
+    try:
+        # Validate inputs
+        text = text.strip() if text else ""
+        if not url:
+            url = "https://example.com"
+        try:
+            parsed_url = urlparse(url)
+            domain = parsed_url.netloc or "example.com"
+        except Exception:
+            logging.warning(f"Invalid URL: {url}. Using default domain.")
+            domain = "example.com"
+
+        # Check cache
+        cache_key = f"summarize_{hash(text + url)}"
+        if cache_key in cache:
+            logging.info(f"Cache hit for {cache_key}")
+            return cache[cache_key]
+
+        # Get Gemini API key
+        api_key = os.getenv("GEMINI_API_KEY")
+        if not api_key:
+            logging.error("Gemini API key not found. Please set GEMINI_API_KEY in .env file.")
+            raise ValueError("Gemini API key is required for summarization.")
+
+        # Configure Gemini client
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel('gemini-1.5-flash')
+
+        # Handle short or empty text
+        if len(text) < 20:
+            logging.warning(f"Text too short ({len(text)} chars): '{text}'. Using URL context.")
+            text = f"Content from {url} about news, products, or services."
+
+        # Split text into chunks to avoid quota issues (e.g., 1000 chars per chunk)
+        chunk_size = 1000
+        text_chunks = [text[i:i + chunk_size] for i in range(0, len(text), chunk_size)]
+        summaries = []
+
+        for chunk in text_chunks[:2]:  # Limit to first 2000 chars for efficiency
+            prompt = (
+                f"Summarize the following text into a title (30-50 characters) and a description (80-100 characters) "
+                f"for RCS messaging. Ensure titles are catchy and descriptions are engaging, relevant to the content, "
+                f"and suitable for a news, product, or service context inferred from the URL ({url}). "
+                f"Output as JSON:\n{{\"title\": \"[title]\", \"description\": \"[description]\"}}\n\nText: {chunk}"
+            )
+
+            response = await model.generate_content_async(prompt)
+            raw_content = response.text.strip()
+            logging.info(f"Raw Gemini response: {raw_content}")
+
+            # Parse response with regex
+            try:
+                match = re.search(r'\{[\s\S]*"title":\s*"([^"]+)"[\s\S]*"description":\s*"([^"]+)"[\s\S]*\}', raw_content)
+                if match:
+                    title = match.group(1)
+                    description = match.group(2)
+                    summaries.append({"title": title, "description": description})
+                else:
+                    raise ValueError("Invalid JSON format in Gemini response")
+            except Exception as e:
+                logging.warning(f"Failed to parse Gemini response: {e}. Skipping chunk.")
+                continue
+
+        # Combine summaries (prioritize first valid summary)
+        if summaries:
+            result = summaries[0]
+        else:
+            logging.warning("No valid summaries generated. Using fallback.")
+            result = {
+                "title": "News Summary",
+                "description": f"Discover news and insights from {domain}."[:100]
+            }
+
+        # Ensure non-empty outputs
+        if not result["title"].strip():
+            result["title"] = "News Summary"
+        if not result["description"].strip():
+            result["description"] = f"Discover news and insights from {domain}."[:100]
+
+        cache[cache_key] = result
+        logging.info(f"Summary - Title: {result['title']}, Description: {result['description']}")
+        return result
+
+    except Exception as e:
+        logging.error(f"Error summarizing text: {e}")
+        domain = urlparse(url).netloc or "example.com"
+        result = {
+            "title": "News Summary",
+            "description": f"Discover news and insights from {domain}."[:100]
+        }
+        cache[cache_key] = result
+        return result
+
+async def quick_summarize(text: str, url: str = "") -> Dict[str, str]:
+    """Quickly summarize text with a lightweight prompt using Gemini-1.5 Flash."""
+    try:
+        # Validate inputs
+        text = text.strip() if text else ""
+        if not url:
+            url = "https://example.com"
+        try:
+            parsed_url = urlparse(url)
+            domain = parsed_url.netloc or "example.com"
+        except Exception:
+            logging.warning(f"Invalid URL: {url}. Using default domain.")
+            domain = "example.com"
+
+        # Check cache
+        cache_key = f"quick_summarize_{hash(text + url)}"
+        if cache_key in cache:
+            logging.info(f"Cache hit for {cache_key}")
+            return cache[cache_key]
+
+        # Get Gemini API key
+        api_key = os.getenv("GEMINI_API_KEY")
+        if not api_key:
+            logging.error("Gemini API key not found. Please set GEMINI_API_KEY in .env file.")
+            raise ValueError("Gemini API key is required for summarization.")
+
+        # Configure Gemini client
+        genai.configure(api_key=api_key)
+        model = genai.GenerativeModel('gemini-1.5-flash')
+
+        # Handle short or empty text
+        if len(text) < 20:
+            logging.warning(f"Text too short ({len(text)} chars): '{text}'. Using URL context.")
+            text = f"Content from {url} about news, products, or services."
+
+        # Lightweight prompt with chunking
+        chunk_size = 1000
+        text_chunks = [text[i:i + chunk_size] for i in range(0, len(text), chunk_size)]
+        summaries = []
+
+        for chunk in text_chunks[:1]:  # Limit to first 1000 chars for quick summary
+            prompt = (
+                f"Create a title (30-50 chars) and description (80-100 chars) for RCS messaging from this text. "
+                f"Keep it engaging and relevant to {url}. Output as JSON:\n{{\"title\": \"[title]\", \"description\": \"[description]\"}}\n\nText: {chunk}"
+            )
+
+            response = await model.generate_content_async(prompt)
+            raw_content = response.text.strip()
+            logging.info(f"Raw Gemini response (quick): {raw_content}")
+
+            # Parse response with regex
+            try:
+                match = re.search(r'\{[\s\S]*"title":\s*"([^"]+)"[\s\S]*"description":\s*"([^"]+)"[\s\S]*\}', raw_content)
+                if match:
+                    title = match.group(1)[:50]
+                    description = match.group(2)[:100]
+                    summaries.append({"title": title, "description": description})
+                else:
+                    raise ValueError("Invalid JSON format in Gemini response")
+            except Exception as e:
+                logging.warning(f"Failed to parse Gemini response: {e}. Skipping chunk.")
+                continue
+
+        # Use first valid summary or fallback
+        if summaries:
+            result = summaries[0]
+        else:
+            logging.warning("No valid summaries generated. Using fallback.")
+            result = {
+                "title": "Quick Summary",
+                "description": f"Check out content from {domain}."[:100]
+            }
+
+        # Ensure non-empty outputs
+        if not result["title"].strip():
+            result["title"] = "Quick Summary"
+        if not result["description"].strip():
+            result["description"] = f"Check out content from {domain}."[:100]
+
+        cache[cache_key] = result
+        logging.info(f"Quick summary - Title: {result['title']}, Description: {result['description']}")
+        return result
+
+    except Exception as e:
+        logging.error(f"Error in quick summarize: {e}")
+        domain = urlparse(url).netloc or "example.com"
+        result = {
+            "title": "Quick Summary",
+            "description": f"Check out content from {domain}."[:100]
+        }
+        cache[cache_key] = result
+        return result