Update app.py

app.py

@@ -1,3 +1,4 @@
+# app.py - Flask Backend with AI URL Shortening System
 from flask import Flask, request, jsonify, send_from_directory, make_response
 import google.generativeai as genai
 from dotenv import load_dotenv
@@ -12,14 +13,14 @@ import uuid
 # Load environment variables
 load_dotenv()
 
-# Directories
+# Configure paths
 AUDIO_FOLDER = os.path.join('static', 'audio')
 os.makedirs(AUDIO_FOLDER, exist_ok=True)
 
 app = Flask(__name__, static_folder='static')
 CORS(app)
 
-# Gemini AI Configuration
+# AI Configuration - Critical for URL detection and formatting
 system_instruction = """
 You are a helpful AI assistant named Athspi. When responding:
 1. Never mention "audio" or technical terms
@@ -28,11 +29,12 @@ You are a helpful AI assistant named Athspi. When responding:
 3. Keep responses natural and friendly
 4. Decide automatically when to include audio based on the content type
 5. For stories, always include audio version
-6. If a URL is present in the user's message, respond with:
+6. CRITICAL: When you detect a URL in the user's message, respond with:
    [SHORTEN]original_url|short_url[/SHORTEN]
-   Example:
-   I've shortened your link for convenience:
+   Example format ONLY:
    [SHORTEN]https://example.com|https://spoo.me/abc123[/SHORTEN]
+7. DO NOT add any extra text inside the SHORTEN tags
+8. ONLY use this format when you have a shortened URL to provide
 """
 
 genai.configure(api_key=os.getenv("GEMINI_API_KEY"))
@@ -42,28 +44,37 @@ model = genai.GenerativeModel('gemini-2.5-flash', system_instruction=system_inst
 chat_sessions = {}
 
 def convert_markdown_to_html(text):
+    """Convert markdown to HTML with code formatting"""
     html = markdown2.markdown(text, extras=["fenced-code-blocks", "tables"])
     html = re.sub(r'<pre><code(.*?)>', r'<pre class="code-block"><code\1>', html)
     return html
 
 def process_response(full_response):
-    """Extract visible text, audio content, and short links"""
+    """Extract visible text, audio content, and short links from AI response"""
+    # Extract audio content
     audio_match = re.search(r'\[AUDIO\](.*?)\[/AUDIO\]', full_response, re.DOTALL)
     audio_content = audio_match.group(1).strip() if audio_match else None
     visible_text = re.sub(r'\[/?AUDIO\]', '', full_response)
-
+    
+    # Process short links - CRITICAL PART
     short_link_match = re.search(r'\[SHORTEN\](.*?)\|([^|]*?)\[/SHORTEN\]', visible_text, re.DOTALL)
     if short_link_match:
         original_url = short_link_match.group(1).strip()
         short_url = short_link_match.group(2).strip()
-        link_html = f'<p><strong>🔗 Original:</strong> <a href="{original_url}" target="_blank">{original_url}</a></p>' \
-                    f'<p><strong>✂️ Shortened:</strong> <a href="{short_url}" target="_blank">{short_url}</a></p>'
+        
+        # Create clean HTML for display
+        link_html = f'<div class="link-container">' \
+                    f'<p><strong>🔗 Original:</strong> <a href="{original_url}" target="_blank" rel="noopener noreferrer">{original_url}</a></p>' \
+                    f'<p><strong>✂️ Shortened:</strong> <a href="{short_url}" target="_blank" rel="noopener noreferrer">{short_url}</a></p>' \
+                    f'</div>'
+        
+        # Replace the SHORTEN tags with our clean HTML
         visible_text = re.sub(r'\[SHORTEN\].*?\[/SHORTEN\]', link_html, visible_text)
 
     return visible_text, audio_content
 
 def generate_audio(text):
-    """Generate audio file from text"""
+    """Generate audio file from text, cleaning special characters"""
     text = re.sub(r'[^\w\s.,!?\-]', '', text)
     filename = f"audio_{uuid.uuid4()}.mp3"
     filepath = os.path.join(AUDIO_FOLDER, filename)
@@ -72,37 +83,48 @@ def generate_audio(text):
     return filename
 
 def shorten_url_with_spoo_me(url):
-    """Shorten URL using spoo.me API and clean output"""
+    """Shorten URL using spoo.me API with proper error handling"""
     try:
+        # Clean the input URL
         clean_url = url.strip()
         if not clean_url.startswith(('http://', 'https://')):
             clean_url = 'https://' + clean_url
 
-        payload = {"url": clean_url}
+        payload = {
+            "url": clean_url
+        }
         headers = {
             "Accept": "application/json",
             "Content-Type": "application/x-www-form-urlencoded"
         }
 
-        response = requests.post("https://spoo.me/", data=payload, headers=headers, timeout=10)
+        response = requests.post(
+            "https://spoo.me/",
+            data=payload,
+            headers=headers,
+            timeout=10
+        )
 
         if response.status_code == 200:
             try:
+                # Parse the JSON response
                 result = response.json()
-                original_url = result.get("original_url", "").strip()
+                # Extract short_url and strip whitespace
                 short_url = result.get("short_url", "").strip()
-                if short_url:
-                    print(f"Spoo.me returned: {original_url} → {short_url}")
+                if short_url and short_url.startswith('http'):
                     return short_url
             except Exception as json_error:
-                print("JSON parse error:", json_error)
-                return None
+                print("JSON parse error:", str(json_error))
+                # Fallback for plain text response
+                text_response = response.text.strip()
+                if text_response.startswith('http'):
+                    return text_response
 
-        print(f"Spoo.me error: {response.status_code} - {response.text}")
+        print(f"spoo.me error: {response.status_code} - {response.text}")
         return None
 
     except Exception as e:
-        print("Request failed:", e)
+        print("Request failed:", str(e))
         return None
 
 @app.route('/chat', methods=['POST'])
@@ -120,19 +142,37 @@ def chat():
             chat_sessions[session_id] = model.start_chat(history=[])
         chat_session = chat_sessions[session_id]
 
-        # AI response
-        response = chat_session.send_message(user_message)
-        full_text = response.text
-
-        # Detect and shorten first URL
+        # Check if user message contains a URL
         url_match = re.search(r'https?://[^\s<>"{}|\\^`\[\]]+', user_message)
+        ai_response = None
+        full_text = ""
+        
         if url_match:
             original_url = url_match.group(0).strip()
             short_url = shorten_url_with_spoo_me(original_url)
-            if short_url and "[SHORTEN]" not in full_text:
+            
+            if short_url:
+                # Format the SHORTEN tag exactly as required
                 short_tag = f"[SHORTEN]{original_url}|{short_url}[/SHORTEN]"
-                full_text += f"\n\n{short_tag}"
-
+                
+                # Send message to AI with instruction to include short link
+                ai_response = chat_session.send_message(
+                    f"User sent this message: '{user_message}'\n\n"
+                    f"I found a URL: {original_url}\n"
+                    f"Shortened URL: {short_url}\n\n"
+                    f"Respond naturally and include this exact format:\n{short_tag}"
+                )
+                full_text = ai_response.text
+            else:
+                # If shortening failed, just send normal message
+                ai_response = chat_session.send_message(user_message)
+                full_text = ai_response.text
+        else:
+            # No URL found, normal chat
+            ai_response = chat_session.send_message(user_message)
+            full_text = ai_response.text
+
+        # Process final response
         visible_text, audio_content = process_response(full_text)
         html_response = convert_markdown_to_html(visible_text)
 
@@ -141,12 +181,13 @@ def chat():
             "has_audio": False
         }
 
+        # Generate audio if needed
         if audio_content:
             audio_filename = generate_audio(audio_content)
             result["audio_filename"] = audio_filename
             result["has_audio"] = True
 
-        # Set session ID in cookie
+        # Return response + set session cookie
         resp = make_response(jsonify(result))
         resp.set_cookie('session_id', session_id, max_age=3600, httponly=True, samesite='Lax')
         return resp
@@ -157,6 +198,7 @@ def chat():
 
 @app.route('/new-chat', methods=['POST'])
 def new_chat():
+    """Reset chat memory"""
     session_id = str(uuid.uuid4())
     resp = make_response(jsonify({"status": "new chat started"}))
     resp.set_cookie('session_id', session_id, max_age=3600, httponly=True, samesite='Lax')
@@ -178,4 +220,4 @@ def serve_static(path):
     return send_from_directory('static', path)
 
 if __name__ == '__main__':
-    app.run(host="0.0.0.0", port=7860)
+    app.run(host="0.0.0.0", port=7860)