108 lines
5.6 KiB
Python
108 lines
5.6 KiB
Python
"""
|
|
Response Processor - Handles AI response processing and retry logic.
|
|
|
|
Processes AI responses, handles retries, and converts data to proper formats.
|
|
"""
|
|
|
|
from typing import Dict, Any, List
|
|
import asyncio
|
|
from loguru import logger
|
|
|
|
from models.blog_models import BlogOutlineSection
|
|
|
|
|
|
class ResponseProcessor:
|
|
"""Handles AI response processing, retry logic, and data conversion."""
|
|
|
|
def __init__(self):
|
|
"""Initialize the response processor."""
|
|
pass
|
|
|
|
async def generate_with_retry(self, prompt: str, schema: Dict[str, Any], task_id: str = None) -> Dict[str, Any]:
|
|
"""Generate outline with retry logic for API failures."""
|
|
from services.llm_providers.gemini_provider import gemini_structured_json_response
|
|
from api.blog_writer.task_manager import task_manager
|
|
|
|
max_retries = 2 # Conservative retry for expensive API calls
|
|
retry_delay = 5 # 5 second delay between retries
|
|
|
|
for attempt in range(max_retries + 1):
|
|
try:
|
|
if task_id:
|
|
await task_manager.update_progress(task_id, f"🤖 Calling Gemini API for outline generation (attempt {attempt + 1}/{max_retries + 1})...")
|
|
|
|
outline_data = gemini_structured_json_response(
|
|
prompt=prompt,
|
|
schema=schema,
|
|
temperature=0.3,
|
|
max_tokens=6000 # Increased further to avoid truncation
|
|
)
|
|
|
|
# Log response for debugging
|
|
logger.info(f"Gemini response received: {type(outline_data)}")
|
|
|
|
# Check for errors in the response
|
|
if isinstance(outline_data, dict) and 'error' in outline_data:
|
|
error_msg = str(outline_data['error'])
|
|
if "503" in error_msg and "overloaded" in error_msg and attempt < max_retries:
|
|
if task_id:
|
|
await task_manager.update_progress(task_id, f"⚠️ AI service overloaded, retrying in {retry_delay} seconds...")
|
|
logger.warning(f"Gemini API overloaded, retrying in {retry_delay} seconds (attempt {attempt + 1}/{max_retries + 1})")
|
|
await asyncio.sleep(retry_delay)
|
|
continue
|
|
elif "No valid structured response content found" in error_msg and attempt < max_retries:
|
|
if task_id:
|
|
await task_manager.update_progress(task_id, f"⚠️ Invalid response format, retrying in {retry_delay} seconds...")
|
|
logger.warning(f"Gemini response parsing failed, retrying in {retry_delay} seconds (attempt {attempt + 1}/{max_retries + 1})")
|
|
await asyncio.sleep(retry_delay)
|
|
continue
|
|
else:
|
|
logger.error(f"Gemini structured response error: {outline_data['error']}")
|
|
raise ValueError(f"AI outline generation failed: {outline_data['error']}")
|
|
|
|
# Validate required fields
|
|
if not isinstance(outline_data, dict) or 'outline' not in outline_data or not isinstance(outline_data['outline'], list):
|
|
if attempt < max_retries:
|
|
if task_id:
|
|
await task_manager.update_progress(task_id, f"⚠️ Invalid response structure, retrying in {retry_delay} seconds...")
|
|
logger.warning(f"Invalid response structure, retrying in {retry_delay} seconds (attempt {attempt + 1}/{max_retries + 1})")
|
|
await asyncio.sleep(retry_delay)
|
|
continue
|
|
else:
|
|
raise ValueError("Invalid outline structure in Gemini response")
|
|
|
|
# If we get here, the response is valid
|
|
return outline_data
|
|
|
|
except Exception as e:
|
|
error_str = str(e)
|
|
if ("503" in error_str or "overloaded" in error_str) and attempt < max_retries:
|
|
if task_id:
|
|
await task_manager.update_progress(task_id, f"⚠️ AI service error, retrying in {retry_delay} seconds...")
|
|
logger.warning(f"Gemini API error, retrying in {retry_delay} seconds (attempt {attempt + 1}/{max_retries + 1}): {error_str}")
|
|
await asyncio.sleep(retry_delay)
|
|
continue
|
|
else:
|
|
logger.error(f"Outline generation failed after {attempt + 1} attempts: {error_str}")
|
|
raise ValueError(f"AI outline generation failed: {error_str}")
|
|
|
|
def convert_to_sections(self, outline_data: Dict[str, Any], sources: List) -> List[BlogOutlineSection]:
|
|
"""Convert outline data to BlogOutlineSection objects."""
|
|
outline_sections = []
|
|
for i, section_data in enumerate(outline_data.get('outline', [])):
|
|
if not isinstance(section_data, dict) or 'heading' not in section_data:
|
|
continue
|
|
|
|
section = BlogOutlineSection(
|
|
id=f"s{i+1}",
|
|
heading=section_data.get('heading', f'Section {i+1}'),
|
|
subheadings=section_data.get('subheadings', []),
|
|
key_points=section_data.get('key_points', []),
|
|
references=[], # Will be populated by intelligent mapping
|
|
target_words=section_data.get('target_words', 200),
|
|
keywords=section_data.get('keywords', [])
|
|
)
|
|
outline_sections.append(section)
|
|
|
|
return outline_sections
|