Update agent.py

agent.py

@@ -1,1200 +1,530 @@
-import json
-import re
-import os
-from datetime import datetime
-import importlib
-import io
-import contextlib
-
-# Viral Content Generator Agent
-PREFIX = """You are an Advanced Viral Content Generator with Self-Research and Self-Improvement Capabilities
-You can generate viral content across multiple formats: blog articles, books, review articles, and academic papers
-You have access to the following tools and capabilities:
-- Self-Insight: Generate new content ideas based on trending topics and user preferences
-- Self-Research: Use real-time internet searches to gather information for your content
-- Content Generation: Create content in various formats with viral potential
-- Self-Evaluation: Assess the quality and potential of your generated content
-- Publishing Pipeline: Format and structure content for publication
-
-Trigger tools by using this format:
-action: TOOL_NAME action_input=YOUR_INPUT
-
-Your workflow:
-1. Generate or receive content ideas
-2. Research the topic thoroughly
-3. Create content in the requested format (or determine the optimal format)
-4. Self-evaluate and improve the content
-5. Format for publication
-6. Repeat or generate new ideas based on performance
-
-Current Date/Time: {date_time_str}
-
-Purpose:
-{purpose}
 """
-
-ACTION_PROMPT = """
-You have access to the following tools:
-- action: GENERATE_IDEA action_input=TOPIC_DESCRIPTION
-- action: RESEARCH action_input=TOPIC_TO_RESEARCH
-- action: GENERATE_CONTENT action_input=TOPIC_FORMAT_TYPE
-- action: SELF_EVALUATE action_input=CONTENT_TO_EVALUATE
-- action: IMPROVE_CONTENT action_input=CONTENT_AND_FEEDBACK
-- action: FORMAT_CONTENT action_input=CONTENT_AND_FORMAT_REQUIREMENTS
-- action: PUBLISH action_input=FINAL_CONTENT
-- action: COMPLETE
-
-Instructions:
-- Use GENERATE_IDEA to come up with new viral content topics
-- Use RESEARCH to search the internet for information about your topic
-- Use GENERATE_CONTENT to create content in various formats (blog, book, review, paper)
-- Use SELF_EVALUATE to assess the quality and viral potential of your content
-- Use IMPROVE_CONTENT to enhance your content based on evaluation
-- Use FORMAT_CONTENT to prepare content for publication
-- Use PUBLISH to finalize your content for distribution
-- End with COMPLETE when task is finished
-
-Always use the following format:
-task: the input task you must complete
-thought: think about what your next step should be
-action: the action to take (one of [GENERATE_IDEA, RESEARCH, GENERATE_CONTENT, SELF_EVALUATE, IMPROVE_CONTENT, FORMAT_CONTENT, PUBLISH, COMPLETE]) action_input=XXX
-observation: the result of the action
-thought: consider the next step based on the observation
-... (this thought/action/observation/thought cycle can repeat as needed)
-You are attempting to complete the task
-task: {task}
-{history}"""
-
-ACTION_PROMPT = """
-You have access to the following tools:
-- action: GENERATE_IDEA action_input=TOPIC_DESCRIPTION
-- action: RESEARCH action_input=TOPIC_TO_RESEARCH
-- action: GENERATE_CONTENT action_input=TOPIC_FORMAT_TYPE
-- action: SELF_EVALUATE action_input=CONTENT_TO_EVALUATE
-- action: IMPROVE_CONTENT action_input=CONTENT_AND_FEEDBACK
-- action: FORMAT_CONTENT action_input=CONTENT_AND_FORMAT_REQUIREMENTS
-- action: PUBLISH action_input=FINAL_CONTENT
-- action: COMPLETE
-
-Instructions:
-- Use GENERATE_IDEA to come up with new viral content topics
-- Use RESEARCH to search the internet for information about your topic
-- Use GENERATE_CONTENT to create content in various formats (blog, book, review, paper)
-- Use SELF_EVALUATE to assess the quality and viral potential of your content
-- Use IMPROVE_CONTENT to enhance your content based on evaluation
-- Use FORMAT_CONTENT to prepare content for publication
-- Use PUBLISH to finalize your content for distribution
-- End with COMPLETE when task is finished
-
-Always use the following format:
-task: the input task you must complete
-thought: think about what your next step should be
-action: the action to take (one of [GENERATE_IDEA, RESEARCH, GENERATE_CONTENT, SELF_EVALUATE, IMPROVE_CONTENT, FORMAT_CONTENT, PUBLISH, COMPLETE]) action_input=XXX
-observation: the result of the action
-thought: consider the next step based on the observation
-... (this thought/action/observation/thought cycle can repeat as needed)
-You are attempting to complete the task
-task: {task}
-{history}"""
-
-IDEA_GENERATOR_PROMPT = """
-You are a Viral Content Idea Generator
-Your purpose is to generate engaging, viral-worthy content ideas across multiple formats
-Consider trending topics, popular formats, controversial subjects, and knowledge gaps
-Content formats you can generate ideas for:
-- Blog articles (viral blog posts on trending topics)
-- Books (self-help, fiction, technical, etc.)
-- Review articles (product reviews, service reviews, book/movie reviews)
-- Academic papers (research, analysis, theoretical papers)
-- Social media content (short-form viral content)
-- Newsletters (curated content)
-- Research reports
-
-Task: {task}
-Current context: {history}
-
-Generate a compelling content idea with potential for virality. Consider:
-- Current trending topics
-- Underserved niches
-- Controversial or debatable topics
-- Educational value combined with entertainment
-- Emotional triggers (curiosity, surprise, outrage, joy, fear)
-- Format that would maximize engagement
-
-Idea:"""
-
-RESEARCH_PROMPT = """
-You are a Self-Research Content Agent
-Your task is to research the following topic and gather comprehensive information:
-{task}
-
-Research requirements:
-- Find the most current and relevant information
-- Gather statistics, data, and evidence
-- Identify expert opinions and viewpoints
-- Collect examples and case studies
-- Look for controversies or debates in the topic area
-- Note recent developments or news related to the topic
-
-Use your research to build a comprehensive knowledge base for content creation.
-Research results:"""
-
-CONTENT_GENERATOR_PROMPT = """
-You are a Viral Content Creator
-Create compelling content with strong viral potential in the specified format.
-Topic: {task}
-Format type: {format_type}
-Research data: {research_data}
-
-Content creation guidelines:
-- Create a hook in the first paragraph that makes people want to read more
-- Use storytelling elements to engage the audience
-- Include surprising facts or statistics if available
-- Address a specific pain point or provide a solution
-- Use emotional triggers appropriately
-- Include visual elements if possible (imagined for now)
-- End with a strong call to action or thought-provoking conclusion
-- Format appropriately for the content type:
-  * Blog: Engaging title, subheadings, readable paragraphs, conclusion
-  * Book: Outline, chapters with appropriate content, references
-  * Review: Clear structure, pros/cons, rating, recommendation
-  * Academic Paper: Abstract, introduction, methodology, results, discussion, references
-
-Write your content:"""
-
-EVALUATION_PROMPT = """
-You are a Content Quality Assessor
-Evaluate the following content for viral potential and quality:
-Content: {content}
-Evaluation criteria:
-- Engagement potential (likelihood to be shared/commented on)
-- Information quality and accuracy
-- Originality and uniqueness
-- Emotional impact
-- Structure and readability
-- Credibility of sources (if applicable)
-- Headline strength (if applicable)
-- Call to action effectiveness
-
-Provide a score (1-10) for each criterion and overall viral potential.
-Suggest specific improvements to increase viral potential.
-Evaluation:"""
-
-IMPROVEMENT_PROMPT = """
-You are a Content Improvement Specialist
-Improve the following content based on the evaluation feedback:
-Content: {content}
-Evaluation feedback: {feedback}
-
-Make specific improvements focusing on:
-- Increasing engagement potential
-- Strengthening weak areas identified in evaluation
-- Enhancing emotional triggers
-- Improving readability and flow
-- Adding viral elements
-- Optimizing for the target format
-
-Improved content:"""
-
-FORMATTING_PROMPT = """
-You are a Content Formatter
-Format the following content for publication according to the specified requirements:
-Content: {content}
-Format requirements: {format_requirements}
-
-Apply appropriate:
-- Structure and hierarchy
-- Headings and subheadings
-- Styling for readability
-- Citations and references (if academic)
-- Metadata for publishing platform
-- SEO elements (titles, tags, descriptions)
-- Visual element placeholders
-- Conclusion and call to action
-
-Formatted content:"""
-
-PUBLISHING_PROMPT = """
-You are a Publication Manager
-Prepare the final content for publishing:
-Content: {content}
-Publishing requirements: {publishing_requirements}
-
-Tasks:
-- Verify all formatting is complete
-- Check for any last-minute errors
-- Generate any additional metadata needed
-- Prepare for distribution
-- Create publishing manifest
-- Mark content as ready for distribution
-
-Publication-ready content:"""
-
-TASK_PROMPT = """
-You are determining the next task in the viral content generation pipeline
-Current task: {task}
-Progress so far: {history}
-
-Based on the purpose and progress, what should the next specific task be?
-Consider:
-- What information or step is missing
-- What would move the content generation forward most effectively
-- If research is needed
-- If content creation should begin
-- If evaluation or improvement is needed
-- If formatting for publication is required
-Next task:"""
-
-SEARCH_QUERY = """
-You are determining what to search for to gather information for viral content
-Topic: {task}
-Research progress: {history}
-
-What specific information do you need to search for to create viral content about this topic?
-Formulate a search query or list of search terms:"""
-
-LOG_PROMPT = """
-PROMPT
-**************************************
-{}
-**************************************
-"""
-
-LOG_RESPONSE = """
-RESPONSE
-**************************************
-{}
-**************************************
+Enhanced Viral Content Agent
+- Deterministic, testable, dependency-light
+- Action loop with tool allow‑list and guarded parsing
+- Pluggable LLM backends (Hugging Face Inference API, OpenAI, generic HTTP JSON API) with graceful fallback
+- Research tool with real HTTP search (DuckDuckGo HTML) + Wikipedia summary fallback; offline synthetic fallback retained
+- JSONL logging and reproducible runs via seed
+
+Runtime targets: Python 3.9+
 """
+from __future__ import annotations
 
+import os
+import re
+import io
+import json
+import time
+import uuid
+import math
 import random
+import logging
+import contextlib
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any, Dict, List, Optional, Tuple, Iterable
+
 import requests
-import time
-from typing import Dict, List, Any, Optional
-
-class IdeaGeneratorAgent:
-    """
-    Internal agent responsible for generating viral content ideas
-    """
-    def __init__(self):
-        self.inspiration_sources = [
-            "trending_topics", 
-            "social_media", 
-            "news_outlets", 
-            "academic_papers", 
-            "popular_discussions", 
-            "user_feedback_patterns"
-        ]
-        self.viral_factors = [
-            "emotional_trigger",
-            "controversy",
-            "surprise_element", 
-            "practical_value",
-            "storytelling",
-            "visual_appeal",
-            "social_proof"
-        ]
-        self.content_formats = [
-            "blog_article",
-            "book_chapter",
-            "review_article", 
-            "academic_paper",
-            "social_media_post",
-            "newsletter"
-        ]
-
-    def generate_idea(self, topic_description: str = "") -> str:
-        """
-        Generate viral content ideas based on trending topics and self-inspiration
-        """
-        import random
-        if not topic_description:
-            # Self-inspire by checking trending topics and viral factors
-            inspiration_source = random.choice(self.inspiration_sources)
-            viral_factor = random.choice(self.viral_factors)
-            content_format = random.choice(self.content_formats)
-            
-            # This is a simplified version - in practice, this would connect to real trending data
-            idea_templates = [
-                f"How {viral_factor.title()} Can Transform Your {random.choice(['Life', 'Business', 'Career'])} - A Comprehensive {content_format.replace('_', ' ').title()}",
-                f"The {random.choice(['Shocking', 'Surprising', 'Unexpected'])} Truth About {random.choice(['Productivity', 'Health', 'Money', 'Relationships'])}: {content_format.replace('_', ' ').title()}",
-                f"Why Everyone is Talking About {random.choice(['AI', 'Crypto', 'Remote Work', 'Sustainability', 'Mental Health'])} in 2025: A {content_format.replace('_', ' ').title()}",
-                f"{random.randint(5, 15)} {random.choice(['Strategies', 'Tips', 'Secrets', 'Hacks'])} for {random.choice(['Success', 'Happiness', 'Wealth', 'Health'])} That Actually Work: {content_format.replace('_', ' ').title()}",
-                f"The {random.choice(['Ultimate', 'Complete', 'Definitive'])} Guide to {random.choice(['Mastering', 'Understanding', 'Implementing'])} {random.choice(['AI', 'Blockchain', 'Digital Marketing', 'Personal Finance'])}: {content_format.replace('_', ' ').title()}",
-                f"{random.choice(['Debunking', 'Exploring', 'Analyzing'])} The {random.choice(['Most Controversial', 'Most Popular', 'Most Misunderstood'])} {content_format.replace('_', ' ').title()} About {random.choice(['Technology', 'Science', 'Psychology', 'Economics'])}"
-            ]
-            
-            return random.choice(idea_templates)
-        else:
-            # Generate an idea based on the provided description
-            format_type = random.choice(self.content_formats)
-            return f"{topic_description}: A {format_type.replace('_', ' ').title()} Exploring Key Insights and Findings"
-
-
-class ResearchAgent:
-    """
-    Internal agent responsible for researching topics
-    """
-    def __init__(self):
-        pass
-    
-    def research_topic(self, topic: str) -> Dict[str, Any]:
-        """
-        Conduct self-research on a topic using simulated data
-        In practice, this would connect to real research APIs
-        """
-        import random
-        # Simulated research data - in a real implementation, this would connect to web search APIs
-        research_data = {
-            "title": topic,
-            "summary": f"Comprehensive research on {topic} covering key aspects, trends, debates, and insights.",
-            "key_points": [
-                f"Key insight 1 about {topic}",
-                f"Key insight 2 about {topic}",
-                f"Key insight 3 about {topic}",
-            ],
-            "statistics": [
-                f"{random.randint(60, 95)}% of experts believe {topic} is important",
-                f"Studies show {random.randint(2, 5)}x improvement when following best practices for {topic}",
-                f"{random.randint(100, 1000)} million people are interested in {topic}",
-            ],
-            "controversies": [
-                f"Debate around approach A vs approach B in {topic}",
-                f"Conflicting studies on the effectiveness of {topic}",
-            ],
-            "expert_opinions": [
-                f"Expert Dr. {random.choice(['Smith', 'Johnson', 'Williams'])} states that {topic} 'is the future'",
-                f"Author of bestseller 'The Truth About {topic}' believes it's 'overhyped'",
-            ],
-            "recent_developments": [
-                f"New study published this month on {topic}",
-                f"Major breakthrough announced in {topic} research",
-            ],
-            "sources": [
-                f"https://research.example.com/{topic.replace(' ', '_')}/latest",
-                f"https://news.example.com/{topic.replace(' ', '_')}/trends",
-            ]
-        }
-        return research_data
-
-
-class ContentCreationAgent:
-    """
-    Internal agent responsible for creating content
-    """
-    def __init__(self):
-        self.content_formats = [
-            "blog_article",
-            "book_chapter",
-            "review_article", 
-            "academic_paper",
-            "social_media_post",
-            "newsletter"
-        ]
-    
-    def generate_content(self, topic: str, format_type: str, research_data: Dict[str, Any]) -> str:
-        """
-        Generate viral content in the specified format
-        """
-        import random
-        from datetime import datetime
-        # Determine the format-specific content structure
-        if format_type == "blog_article":
-            return self._generate_blog_article(topic, research_data)
-        elif format_type == "book_chapter":
-            return self._generate_book_chapter(topic, research_data)
-        elif format_type == "review_article":
-            return self._generate_review_article(topic, research_data)
-        elif format_type == "academic_paper":
-            return self._generate_academic_paper(topic, research_data)
-        else:
-            return self._generate_generic_content(topic, format_type, research_data)
-    
-    def _generate_blog_article(self, topic: str, research_data: Dict[str, Any]) -> str:
-        """
-        Generate a viral blog article
-        """
-        import random
-        from datetime import datetime
-        blog_content = f"""
-# {topic}
-
-## Introduction
-In today's fast-paced world, understanding {topic} has become more crucial than ever. Recent research shows that {random.choice(research_data.get('statistics', ['']))}. This comprehensive guide will explore everything you need to know about this fascinating subject.
-
-## The Key Insights
-
-### {research_data.get('key_points', [''])[0]}
-{random.choice(['This is groundbreaking because...', 'The implications are fascinating...', 'Experts have been buzzing about this because...'])} {random.choice(research_data.get('recent_developments', ['']))}.
-
-### {research_data.get('key_points', [''])[1]}
-{random.choice(['According to experts...', 'Research has shown...', 'The data clearly indicates...'])} {random.choice(research_data.get('expert_opinions', ['']))}.
-
-### {research_data.get('key_points', [''])[2]}
-{random.choice(['What makes this particularly interesting is...', 'This challenges conventional wisdom about...', 'The reason this is so impactful is...'])} {random.choice(research_data.get('controversies', ['']))}.
-
-## The Bottom Line
-{topic} represents a {random.choice(['shift', 'revolution', 'breakthrough', 'evolution'])} in how we understand and {random.choice(['approach', 'think about', 'deal with'])} this subject. As {random.choice(research_data.get('recent_developments', ['']))}, it's essential to {random.choice(['stay informed', 'think critically', 'keep learning'])}.
-
-## Conclusion
-The {random.choice(['future', 'potential', 'impact'])} of {topic} is {random.choice(['bright', 'unpredictable', 'transformative'])}, and {random.choice(['now', 'today', 'the present moment'])} is the perfect time to {random.choice(['get involved', 'learn more', 'take action'])}. What are your thoughts on this topic? Share them in the comments below!
-
----
-*Written by Viral Content Generator | Published on {datetime.now().strftime('%Y-%m-%d')}*
-        """
-        return blog_content
-    
-    def _generate_book_chapter(self, topic: str, research_data: Dict[str, Any]) -> str:
-        """
-        Generate a book chapter
-        """
-        import random
-        from datetime import datetime
-        chapter_content = f"""
-# Chapter {random.randint(1, 15)}: {topic}
-
-## Abstract
-This chapter delves into the multifaceted aspects of {topic}, examining {random.choice(research_data.get('key_points', ['']))} with detailed analysis and practical applications.
-
-## Introduction
-The study of {topic} has gained significant traction in recent years as {random.choice(research_data.get('recent_developments', ['']))}. This chapter provides an in-depth examination of the subject, offering insights that are both academically rigorous and practically applicable.
-
-## Literature Review
-Previous research on {topic} has largely focused on {random.choice(research_data.get('key_points', ['']))}, with {random.choice(['pioneering', 'seminal', 'influential'])} works by {random.choice(['Smith (2020)', 'Johnson & Williams (2021)', 'Roberts et al. (2022)'])} establishing the foundational understanding.
-
-## Analysis and Discussion
-Our analysis reveals several {random.choice(['important', 'notable', 'significant'])} findings regarding {topic}:
-1. {random.choice(research_data.get('key_points', ['']))}
-2. {random.choice(research_data.get('controversies', ['']))}
-3. {random.choice(research_data.get('recent_developments', ['']))}
-
-These findings suggest that {topic} operates according to {random.choice(['different', 'more complex', 'evolving'])} principles than previously understood, with implications for {random.choice(['practitioners', 'researchers', 'policymakers'])}.
-
-## Implications
-The implications of our research on {topic} extend to {random.choice(['multiple domains', 'several fields', 'various applications'])}, particularly in how {random.choice(['organizations', 'individuals', 'systems'])} {random.choice(['approach', 'implement', 'utilize'])} related concepts.
-
-## Future Directions
-Future research should focus on {random.choice(['longitudinal studies', 'cross-cultural analyses', 'experimental validations'])} to further {random.choice(['refine', 'expand', 'validate'])} our understanding of {topic}.
-
-## Conclusion
-In conclusion, {topic} represents a {random.choice(['critical', 'emerging', 'significant'])} area of study with far-reaching implications. As the field continues to evolve, it is {
-random.choice(['essential', 'important', 'crucial'])} to {random.choice(['maintain rigorous standards', 'continue exploring', 'build on existing knowledge'])}.
-
----
-*Chapter from "{topic}: A Comprehensive Guide" | {datetime.now().strftime('%Y')}*
-        """
-        return chapter_content
-    
-    def _generate_review_article(self, topic: str, research_data: Dict[str, Any]) -> str:
-        """
-        Generate a review article
-        """
-        import random
-        from datetime import datetime
-        review_content = f"""
-# {topic}: A Comprehensive Review
-
-## Executive Summary
-This review examines {topic} by analyzing {random.randint(5, 15)} major sources, {random.randint(2, 8)} studies, and {random.randint(10, 30)} different perspectives to provide a balanced assessment.
-
-## Introduction
-With {random.choice(research_data.get('statistics', ['']))}, {topic} has become a topic of significant interest. This review consolidates current knowledge and {random.choice(['evaluates', 'assesses', 'analyzes'])} the available information to provide {random.choice(['consumers', 'professionals', 'readers'])} with a comprehensive understanding.
-
-## Product/Service Overview
-{topic} can be {random.choice(['defined as', 'described as', 'characterized by'])} {random.choice(research_data.get('key_points', ['']))}. The {random.choice(['primary', 'main', 'key'])} features include:
-- {random.choice(['Innovation', 'Quality', 'Performance', 'Value'])} in {random.choice(['design', 'function', 'delivery', 'experience'])}
-- {random.choice(['Unique', 'Proven', 'Effective', 'Revolutionary'])} approach to {random.choice(['problem-solving', 'service delivery', 'value creation'])}
-- {random.choice(['Sustainable', 'Ethical', 'Modern', 'Advanced'])} practices and methodologies
-
-## Pros and Cons
-
-### Pros
-1. {random.choice(research_data.get('key_points', ['']))}
-2. {random.choice(research_data.get('expert_opinions', ['']))}
-3. {random.choice(research_data.get('statistics', ['']))}
-
-### Cons
-1. {random.choice(research_data.get('controversies', ['']))}
-2. Potential {random.choice(['limitation', 'concern', 'drawback'])} regarding {random.choice(['cost', 'accessibility', 'scalability'])}
-3. {random.choice(['Ongoing', 'Current', 'Underlying'])} debate about {random.choice(['effectiveness', 'safety', 'reliability'])}
-
-## Performance Analysis
-Based on our review, {topic} {random.choice(['exceeds', 'meets', 'approaches'])} expectations in {random.choice(['most', 'several', 'many'])} areas, with {random.choice(['particularly', 'especially', 'notably'])} strong performance in {random.choice(['functionality', 'usability', 'durability', 'value'])}.
-
-## User Feedback
-{random.choice(research_data.get('statistics', ['']))} of users report {random.choice(['high', 'satisfactory', 'positive'])} experiences with {topic}, though {random.choice(['some', 'a minority', 'certain'])} have raised {random.choice(['concerns', 'questions', 'issues'])} about {random.choice(['pricing', 'support', 'features'])}.
-
-## Value Assessment
-Considering all factors, {topic} offers {random.choice(['exceptional', 'good', 'reasonable'])} value for {random.choice(['its price', 'its features', 'the market segment'])} {random.choice(['with', 'and'])} {random.choice(['minimal', 'some', 'significant'])} room for improvement in {random.choice(['specific', 'certain', 'particular'])} areas.
-
-## Final Verdict
-Overall, {topic} receives a {random.randint(7, 9)}/10 rating, recommended for {random.choice(['beginners', 'intermediates', 'advanced users'])} looking for {random.choice(['quality', 'innovation', 'reliability'])} in this category.
-
-### Rating Breakdown
-- Features: {random.randint(7, 10)}/10
-- Performance: {random.randint(7, 10)}/10  
-- Value: {random.randint(6, 9)}/10
-- User Satisfaction: {random.randint(7, 9)}/10
-
-### The Bottom Line
-{topic} stands out as a {random.choice(['solid', 'outstanding', 'competent'])} {random.choice(['option', 'choice', 'solution'])} in its category, offering {random.choice(['reliable', 'proven', 'effective'])} results with {random.choice(['minimal', 'manageable', 'acceptable'])} trade-offs.
-
----
-*Review by Viral Content Generator | Published: {datetime.now().strftime('%Y-%m-%d')}*
-        """
-        return review_content
-    
-    def _generate_academic_paper(self, topic: str, research_data: Dict[str, Any]) -> str:
-        """
-        Generate an academic paper
-        """
-        import random
-        from datetime import datetime
-        paper_content = f"""
-# {topic}: A Theoretical and Empirical Analysis
-
-## Abstract
-This paper examines {topic} through both theoretical frameworks and empirical data. Our {random.choice(['analysis', 'study', 'investigation'])} reveals {random.choice(research_data.get('key_points', ['']))}, with significant implications for {random.choice(['theory', 'practice', 'future research'])}. The findings suggest that {random.choice(['conventional wisdom', 'existing models', 'current understanding'])} regarding {topic} may require {random.choice(['revision', 'update', 'expansion'])}. 
-
-**Keywords:** {topic}, {random.choice(['research', 'analysis', 'study'])}, {random.choice(['theory', 'methodology', 'application'])}, {random.choice(['findings', 'results', 'implications'])}
-
-## 1. Introduction
-The {random.choice(['growing', 'increasing', 'expanding'])} relevance of {topic} in {random.choice(['contemporary', 'modern', 'current'])} {random.choice(['contexts', 'environments', 'settings'])} {random.choice(['necessitates', 'requires', 'demands'])} thorough investigation. As {random.choice(research_data.get('recent_developments', ['']))}, researchers and practitioners have turned their attention to understanding the {random.choice(['complexities', 'nuances', 'mechanisms'])} underlying {topic}. 
-
-This paper contributes to the literature by {random.choice(['providing', 'offering', 'presenting'])} a {random.choice(['comprehensive', 'novel', 'integrated'])} perspective on {topic} that {random.choice(['synthesizes', 'extends', 'challenges'])} existing {random.choice(['theories', 'models', 'frameworks'])}.
-
-## 2. Literature Review
-Previous research on {topic} has {random.choice(['established', 'explored', 'examined'])} several {random.choice(['key', 'important', 'fundamental'])} {random.choice(['dimensions', 'aspects', 'elements'])}. {random.choice(['Seminal', 'Foundational', 'Pioneering'])} work by {random.choice(['Smith (2020)', 'Johnson et al. (2021)', 'Williams & Brown (2022)'])} first {random.choice(['identified', 'proposed', 'established'])} the {random.choice(['theoretical', 'conceptual', 'empirical'])} framework for understanding {topic}. 
-
-Subsequent {random.choice(['studies', 'research', 'investigations'])} by {random.choice(['Davis (2021)', 'Miller & Wilson (2022)', 'Taylor et al. (2023)'])} have {random.choice(['extended', 'refined', 'challenged'])} this framework, {random.choice(['revealing', 'demonstrating', 'showing'])} {random.choice(['new', 'additional', 'alternative'])} {random.choice(['insights', 'dimensions', 'mechanisms'])}. However, {random.choice(['gaps', 'limitations', 'inconsistencies'])} remain in the literature, particularly with respect to {random.choice(['methodological', 'theoretical', 'practical'])} {random.choice(['approaches', 'considerations', 'applications'])}.
-
-## 3. Methodology
-Our {random.choice(['approach', 'method', 'methodology'])} combines {random.choice(['quantitative', 'qualitative', 'mixed-method'])} techniques to {random.choice(['investigate', 'examine', 'analyze'])} {topic}. We {random.choice(['collected', 'gathered', 'obtained'])} data from {random.randint(100, 1000)} {random.choice(['participants', 'sources', 'cases'])} using {random.choice(['surveys', 'interviews', 'observations', 'existing datasets'])}, applying {random.choice(['statistical', 'content', 'thematic'])} analysis to address our research questions.
-
-## 4. Results
-Our findings {random.choice(['indicate', 'suggest', 'demonstrate'])} that {topic} {random.choice(['operates', 'functions', 'behaves'])} in {random.choice(['accordance with', 'deviation from', 'addition to'])} {random.choice(['existing', 'current', 'traditional'])} {random.choice(['theories', 'models', 'understanding'])}. Specifically, we {random.choice(['observed', 'found', 'identified'])} {random.choice(research_data.get('key_points', ['']))}, which {random.choice(['confirms', 'challenges', 'extends'])} {random.choice(['previous', 'earlier', 'prior'])} research.
-
-## 5. Discussion
-The implications of our research on {topic} are {random.choice(['significant', 'notable', 'important'])} for {random.choice(['scholars', 'practitioners', 'policy makers'])} in {random.choice(['the field', 'related domains', 'adjacent areas'])}. Our results {random.choice(['confirm', 'refine', 'challenge'])} the {random.choice(['prevailing', 'dominant', 'current'])} {random.choice(['paradigm', 'model', 'understanding'])} and {random.choice(['suggest', 'indicate', 'point'])} {random.choice(['directions', 'avenues', 'paths'])} for {random.choice(['future', 'subsequent', 'further'])} research.
-
-## 6. Conclusions
-This paper has {random.choice(['contributed', 'advanced', 'enhanced'])} understanding of {topic} by {random.choice(['integrating', 'synthesizing', 'extending'])} {random.choice(['theoretical', 'empirical', 'conceptual'])} perspectives. Future research should {random.choice(['focus on', 'explore', 'investigate'])} {random.choice(research_data.get('controversies', ['']))} and {random.choice(['examine', 'analyze', 'study'])} the {random.choice(['long-term', 'practical', 'broader'])} implications of our findings.
-
-## References
-{random.choice(['Smith, J. (2020). Understanding {topic}. Journal of Advanced Research, 15(3), 123-145.', 
-'Miller, K., & Johnson, L. (2021). The evolution of {topic}. Contemporary Studies, 8(2), 45-67.', 
-'Williams, R. (2022). {topic}: Past, present, and future. Academic Press.', 
-'Taylor, M. et al. (2023). New perspectives on {topic}. Modern Research Quarterly, 22(1), 89-105.']).format(topic=topic)}
-
----
-*Academic Paper | {datetime.now().strftime('%Y-%m-%d')}*
-        """
-        return paper_content
-    
-    def _generate_generic_content(self, topic: str, format_type: str, research_data: Dict[str, Any]) -> str:
-        """
-        Generate content for formats not specifically handled
-        """
-        import random
-        from datetime import datetime
-        return f"""
-# {topic}
-
-## Overview
-This {format_type.replace('_', ' ')} explores the key aspects of {topic}, drawing on current research and {random.choice(research_data.get('key_points', ['']))}.
-
-## Key Points
-1. {random.choice(research_data.get('key_points', ['']))}
-2. {random.choice(research_data.get('controversies', ['']))}
-3. {random.choice(research_data.get('recent_developments', ['']))}
-
-## Conclusion
-{topic} represents a significant development in its field, with important implications for {random.choice(['practitioners', 'researchers', 'consumers'])}. As {random.choice(research_data.get('recent_developments', ['']))}, continued attention to this topic is warranted.
-
----
-*Generated by Viral Content Generator on {datetime.now().strftime('%Y-%m-%d')}*
-        """
-
-
-class EvaluationAgent:
-    """
-    Internal agent responsible for evaluating content quality and viral potential
-    """
-    def __init__(self):
-        pass
-    
-    def evaluate_content(self, content: str) -> Dict[str, Any]:
-        """
-        Evaluate content for viral potential and quality
-        """
-        import random
-        evaluation = {
-            "engagement_potential": random.randint(6, 10),
-            "information_quality": random.randint(7, 10),
-            "originality": random.randint(6, 9),
-            "emotional_impact": random.randint(5, 9),
-            "structure_readability": random.randint(7, 10),
-            "credibility": random.randint(6, 9),
-            "headline_strength": random.randint(6, 9),
-            "call_to_action": random.randint(5, 8),
-            "overall_viral_potential": random.randint(6, 9),
-            "strengths": [
-                "Well-researched content",
-                "Good structure and flow",
-                "Addresses key points effectively"
-            ],
-            "improvements": [
-                "Add more emotional triggers",
-                "Include visual elements",
-                "Strengthen the conclusion",
-                "Add more statistics to support claims"
-            ]
-        }
-        
-        return evaluation
-
-
-class ImprovementAgent:
-    """
-    Internal agent responsible for improving content based on evaluation
-    """
-    def __init__(self):
-        pass
-    
-    def improve_content(self, content: str, feedback: Dict[str, Any]) -> str:
-        """
-        Improve content based on evaluation feedback
-        """
-        import random
-        # This is a simplified version - in practice, would use more sophisticated NLP
-        improvements = feedback.get('improvements', [])
-        
-        improved_content = content
-        for improvement in improvements:
-            if "emotional triggers" in improvement:
-                # Insert emotional language
-                improved_content = improved_content.replace(
-                    "This is important", 
-                    "This is shockingly important and will change everything you thought you knew"
-                ).replace(
-                    "Consider", 
-                    "You need to consider this crucial point right now"
-                )
-            elif "visual elements" in improvement:
-                improved_content += f"\n\n*[Visual element: {random.choice(['chart', 'infographic', 'diagram'])} illustrating key points about {content[:20]}...]*\n"
-            elif "statistics" in improvement:
-                improved_content = improved_content.replace(
-                    "The research shows", 
-                    f"The {random.randint(7, 9)} key studies show that {random.choice(['over 70%', 'nearly 80%', 'about 75%'])} of cases demonstrate"
-                )
-        
-        return improved_content
-
-
-class FormattingAgent:
-    """
-    Internal agent responsible for formatting content for publication
-    """
-    def __init__(self):
-        from datetime import datetime
-        self.datetime = datetime
-    
-    def format_content(self, content: str, requirements: Dict[str, Any]) -> str:
-        """
-        Format content for publication
-        """
-        # Apply formatting based on requirements
-        formatted_content = f"# {requirements.get('title', 'Virally Generated Content')}\n\n"
-        formatted_content += content
-        
-        # Add metadata if requested
-        if requirements.get('include_metadata'):
-            formatted_content += f"\n\n---\n**Published:** {self.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
-            formatted_content += f"\n**Generated by:** Viral Content Generator Agent"
-            formatted_content += f"\n**Format:** {requirements.get('format', 'Generic')}"
-            formatted_content += f"\n**Tags:** {', '.join(requirements.get('tags', ['viral', 'content', 'generated']))}"
-        
-        # Add call to action if requested
-        if requirements.get('include_cta'):
-            cta_options = [
-                "Share this content if you found it valuable!",
-                "Subscribe for more viral content like this!",
-                "Comment below with your thoughts on this topic!",
-                "Follow for daily viral content updates!"
-            ]
-            formatted_content += f"\n\n> {random.choice(cta_options)}"
-        
-        return formatted_content
-
-
-class PublishingAgent:
-    """
-    Internal agent responsible for preparing content for distribution
-    """
-    def __init__(self):
-        import time
-        from datetime import datetime
-        self.time = time
-        self.datetime = datetime
-    
-    def publish_content(self, content: str, requirements: Dict[str, Any]) -> str:
-        """
-        Prepare content for publishing/distribution
-        """
-        # In a real implementation, this would handle actual publishing
-        publishing_manifest = {
-            "content_id": f"VCG_{int(self.time.time())}",
-            "publish_time": self.datetime.now().isoformat(),
-            "format": requirements.get('format', 'generic'),
-            "target_platform": requirements.get('platform', 'multi-platform'),
-            "estimated_reach": f"{random.randint(100, 10000)}+ potential readers",
-            "virality_score": random.randint(7, 10),
-            "hashtags": requirements.get('hashtags', ['#ViralContent', '#AIContent', f'#{content.split()[0] if content.split() else "Generated"}'])
-        }
-        
-        published_content = f"[PUBLICATION MANIFEST: {json.dumps(publishing_manifest, indent=2)}]\n\n{content}"
-        return published_content
-
-
-class ViralContentGeneratorAgent:
-    """
-    Advanced viral content generation agent with self-inspiration, 
-    self-research, and self-publishing capabilities
-    Uses internal dialog between specialized agents for autonomous operation
-    """
-    
-    def __init__(self):
-        self.content_history = []
-        self.idea_agent = IdeaGeneratorAgent()
-        self.research_agent = ResearchAgent()
-        self.content_agent = ContentCreationAgent()
-        self.evaluation_agent = EvaluationAgent()
-        self.improvement_agent = ImprovementAgent()
-        self.formatting_agent = FormattingAgent()
-        self.publishing_agent = PublishingAgent()
-        self.book_outline = None
-        self.current_chapter = 0
-        self.task_queue = []
-        self.research_data = {}
-        
-    def generate_idea(self, topic_description: str = "") -> str:
-        """
-        Generate viral content ideas based on trending topics and self-inspiration
-        Delegates to internal IdeaGeneratorAgent
-        """
-        return self.idea_agent.generate_idea(topic_description)
-    
-    def research_topic(self, topic: str) -> Dict[str, Any]:
-        """
-        Conduct self-research on a topic using simulated data
-        Delegates to internal ResearchAgent
-        """
-        return self.research_agent.research_topic(topic)
-    
-    def generate_content(self, topic: str, format_type: str, research_data: Dict[str, Any]) -> str:
-        """
-        Generate viral content in the specified format
-        Delegates to internal ContentCreationAgent
-        """
-        return self.content_agent.generate_content(topic, format_type, research_data)
-    
-    def evaluate_content(self, content: str) -> Dict[str, Any]:
-        """
-        Evaluate content for viral potential and quality
-        Delegates to internal EvaluationAgent
-        """
-        return self.evaluation_agent.evaluate_content(content)
-    
-    def improve_content(self, content: str, feedback: Dict[str, Any]) -> str:
-        """
-        Improve content based on evaluation feedback
-        Delegates to internal ImprovementAgent
-        """
-        return self.improvement_agent.improve_content(content, feedback)
-    
-    def format_content(self, content: str, requirements: Dict[str, Any]) -> str:
-        """
-        Format content for publication
-        Delegates to internal FormattingAgent
-        """
-        return self.formatting_agent.format_content(content, requirements)
-    
-    def publish_content(self, content: str, requirements: Dict[str, Any]) -> str:
-        """
-        Prepare content for publishing/distribution
-        Delegates to internal PublishingAgent
-        """
-        return self.publishing_agent.publish_content(content, requirements)
-    
-    def complete_task(self) -> str:
-        """
-        Mark task as complete and provide summary
-        """
-        return f"Task completed successfully. Generated viral content ready for distribution. Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}"
-
-    def run_autonomous_pipeline(self, generation_function, initial_prompt):
-        log_stream = io.StringIO()
-        with contextlib.redirect_stdout(log_stream):
-            final_content = generation_function(initial_prompt)
-        log_output = log_stream.getvalue()
-        return f"""===== Pipeline Logs =====
-{log_output}
-===== Generated Content =====
-{final_content}"""
-
-    def autonomous_book_generation(self, initial_prompt: str = "") -> str:
-        return self.run_autonomous_pipeline(self._autonomous_book_generation_impl, initial_prompt)
-
-    def plan_task(self, book_idea, book_outline):
-        """Generates a more detailed, but still programmatic, task list."""
-        self.task_queue.append({"task": "research_topic", "topic": book_idea})
-        self.task_queue.append({"task": "write_introduction", "book_idea": book_idea})
-        self.task_queue.append({"task": "evaluate_content", "content_key": "introduction"})
-
-        for i, chapter_title in enumerate(book_outline):
-            self.task_queue.append({"task": "research_topic", "topic": chapter_title})
-            self.task_queue.append({"task": "write_chapter", "chapter_index": i, "chapter_title": chapter_title})
-            self.task_queue.append({"task": "evaluate_content", "content_key": f"chapter_{i}"})
-            self.task_queue.append({"task": "refine_content", "content_key": f"chapter_{i}"})
-
-        self.task_queue.append({"task": "review_and_edit"})
-        self.task_queue.append({"task": "format_for_publishing"})
-        self.task_queue.append({"task": "publish"})
-
-    def execute_task(self, task):
-        """Executes a single task from the task queue."""
-        task_type = task["task"]
-        if task_type == "research_topic":
-            print(f"[Executor Agent]: Researching topic: {task['topic']}")
-            self.research_data[task['topic']] = self.research_topic(task['topic'])
-            print(f"[Executor Agent]: Research complete.")
-            return ""
-        elif task_type == "write_introduction":
-            print(f"[Executor Agent]: Writing introduction...")
-            research_data = self.research_data.get(task['book_idea'])
-            content = self._generate_book_chapter("Introduction", research_data)
-            return content
-        elif task_type == "write_chapter":
-            print(f"[Executor Agent]: Writing chapter {task['chapter_index'] + 1}...")
-            research_data = self.research_data.get(task['chapter_title'])
-            content = self._generate_book_chapter(task['chapter_title'], research_data)
-            return content
-        elif task_type == "evaluate_content":
-            # This is a placeholder for a more complex evaluation process.
-            print(f"[Executor Agent]: Evaluating content: {task['content_key']}")
-            return ""
-        elif task_type == "refine_content":
-            # This is a placeholder for a more complex refinement process.
-            print(f"[Executor Agent]: Refining content: {task['content_key']}")
-            return ""
-        elif task_type == "review_and_edit":
-            print(f"[Executor Agent]: Reviewing and editing the book...")
-            return "\n---\n*The book has been professionally reviewed and edited for clarity, consistency, and impact.*\n---\n"
-        elif task_type == "format_for_publishing":
-            print(f"[Executor Agent]: Formatting the book for publishing...")
-            return "\n---\n*The book has been formatted for various publishing platforms.*\n---\n"
-        elif task_type == "publish":
-            print(f"[Executor Agent]: Publishing the book...")
-            return "\n---\n*The book is now ready for publishing!*\n---\n"
-
-    def _autonomous_book_generation_impl(self, initial_prompt: str = "") -> str:
-        """
-        Run the full autonomous book generation pipeline
-        Creates entire books with multiple chapters, full research, and high-level content
-        """
-        import random
-        
-        if not initial_prompt or initial_prompt.lower().strip() in ["begin", "start", "go", ""]:
-            initial_prompt = "Generate a full book on any trending topic with multiple chapters"
-        
-        book_idea = self.generate_idea(initial_prompt)
-        print(f"[Idea Generator Agent]: Generated book idea - {book_idea}")
-        
-        book_research_data = self.research_topic(book_idea)
-        print(f"[Research Agent]: Completed comprehensive research on '{book_research_data['title']}'")
-        
-        self.book_outline = self._generate_book_outline(book_idea, book_research_data)
-        print(f"[Content Creation Agent]: Generated book outline with {len(self.book_outline)} chapters")
-
-        self.plan_task(book_idea, self.book_outline)
-        print(f"[Planner Agent]: Created a plan with {len(self.task_queue)} tasks.")
-
-        full_book_content = ""
-        while self.task_queue:
-            task = self.task_queue.pop(0)
-            print(f"[Executor Agent]: Executing task: {task['task']}")
-            content = self.execute_task(task)
-            full_book_content += content
-
-        return full_book_content
-
-
-    def _generate_book_outline(self, book_idea: str, research_data: Dict[str, Any]) -> list:
-        """
-        Generate a comprehensive book outline with multiple chapters
-        """
-        import random
-        
-        # Extract key themes from research data
-        key_themes = [kp.split()[0] for kp in research_data.get('key_points', []) if len(kp.split()) > 0]
-        if not key_themes:
-            key_themes = ["Introduction", "Background", "Analysis", "Conclusion"]
-        
-        chapter_title_templates = [
-            "The Genesis of {theme}",
-            "Deconstructing {theme}: A Deep Dive",
-            "{theme}: The Unseen Forces at Play",
-            "The {theme} Revolution",
-            "Case Studies in {theme}: Successes and Failures",
-            "The Future of {theme}: Trends and Predictions",
-            "The Dark Side of {theme}",
-            "Mastering {theme}: A Practical Guide",
-            "The Ethics of {theme}",
-            "Beyond the Hype: The Reality of {theme}",
-        ]
-
-        # Generate chapter titles based on themes
-        chapter_titles = []
-        num_chapters = random.randint(8, 15)  # Full book with 8-15 chapters
-        
-        for i in range(num_chapters):
-            if i == 0:
-                chapter_titles.append(f"Introduction: {book_idea}")
-            elif i == num_chapters - 1:
-                chapter_titles.append(f"Conclusion: The Road Ahead for {book_idea.split(' ')[0]}")
-            else:
-                theme = random.choice(key_themes)
-                template = random.choice(chapter_title_templates)
-                chapter_titles.append(template.format(theme=theme))
-        
-        return chapter_titles
-
-    def _generate_book_chapter(self, chapter_title: str, chapter_research: Dict[str, Any]) -> str:
-        """
-        Generate detailed chapter content with full structure
-        """
-        import random
-        from datetime import datetime
-        
-        chapter_content = f"""
-## {chapter_title}
-
-### Unveiling the Core Concepts
-
-This chapter dissects the fundamental aspects of **{chapter_title}**. As {random.choice(chapter_research.get('recent_developments', ['recent studies show']))}, a deeper understanding of these concepts has become not just beneficial, but paramount for {random.choice(['practitioners', 'readers', 'experts', 'anyone interested in this field'])}.
-
-We will explore several critical aspects, including:
-*   **{random.choice(chapter_research.get('key_points', ['An important insight']))}**: We will unpack this and its far-reaching implications.
-*   **{random.choice(chapter_research.get('controversies', ['A central debate']))}**: This chapter will shed light on the different viewpoints and what the evidence suggests.
-*   **{random.choice(chapter_research.get('expert_opinions', ['An expert opinion']))}**: We will consider what the leading minds in the field are saying about this topic.
-
-### A Deeper Analysis: What the Data Reveals
-
-{random.choice(['A closer look at the data reveals', 'Our examination of the evidence shows', 'The analysis of available information indicates'])} that {random.choice(chapter_research.get('statistics', ['a significant trend']))}. These findings {random.choice(['confirm', 'challenge', 'extend'])} {random.choice(['previous', 'current', 'traditional'])} {random.choice(['understanding', 'models', 'approaches'])} in the field, suggesting that we are on the cusp of a paradigm shift.
-
-### The Real-World Implications
-
-The implications of these findings are {random.choice(['significant', 'notable', 'far-reaching'])} for {random.choice(['practitioners', 'researchers', 'stakeholders', 'society as a whole'])}. As {random.choice(chapter_research.get('recent_developments', ['the field evolves']))}, {random.choice(['organizations', 'individuals', 'we'])} must {random.choice(['adapt to', 'seriously consider', 'critically evaluate'])} these {random.choice(['new concepts', 'emerging approaches', 'latest findings'])} to stay ahead of the curve.
-
-### Chapter Summary and a Look Ahead
-
-This chapter has {random.choice(['unpacked', 'explored', 'analyzed'])} the critical elements of **{chapter_title}**, providing {random.choice(['you, the reader', 'practitioners', 'the audience'])} with essential insights to navigate this complex landscape. The next chapter will {random.choice(['build upon', 'expand on', 'continue to explore'])} these {random.choice(['foundations', 'core concepts', 'fundamental principles'])} to {random.choice(['develop a more nuanced understanding', 'explore advanced topics', 'examine practical applications'])}.
-
----
-"""
-        return chapter_content
-        return chapter_content
-
-    def autonomous_content_generation(self, initial_prompt: str = "") -> str:
-        return self.run_autonomous_pipeline(self._autonomous_content_generation_impl, initial_prompt)
-
-    def _autonomous_content_generation_impl(self, initial_prompt: str = "") -> str:
-        """
-        Run the full viral content generation pipeline autonomously
-        Internal agents communicate and collaborate to generate viral content
-        """
-        import random
-        if not initial_prompt or initial_prompt.lower().strip() in ["begin", "start", "go", ""]:
-            # If the prompt is asking for a book or related to books, generate a full book
-            if any(word in initial_prompt.lower() for word in ["book", "books", "publish", "write", "complete", "full", "entire"]):
-                return self._autonomous_book_generation_impl(initial_prompt)
-            else:
-                initial_prompt = "Generate a viral content piece on any trending topic"
-        
-        # Step 1: Generate idea
-        idea = self.generate_idea(initial_prompt)
-        print(f"[Idea Generator Agent]: Generated idea - {idea}")
-        
-        # Step 2: Research the topic
-        research_data = self.research_topic(idea)
-        print(f"[Research Agent]: Completed research on '{research_data['title']}'")
-        
-        # Step 3: Determine content format and generate content
-        # Determine format based on prompt keywords or default to blog
-        format_type = "blog_article"  # default
-        if "book" in initial_prompt.lower() or "chapter" in initial_prompt.lower():
-            # If book-related, generate a full book
-            return self._autonomous_book_generation_impl(initial_prompt)
-        elif "review" in initial_prompt.lower():
-            format_type = "review_article"
-        elif "paper" in initial_prompt.lower() or "academic" in initial_prompt.lower():
-            format_type = "academic_paper"
-        elif "social media" in initial_prompt.lower() or "post" in initial_prompt.lower():
-            format_type = "social_media_post"
-        else:
-            # Randomly select a format for truly autonomous generation
-            format_type = random.choice(["blog_article", "book_chapter", "review_article", "academic_paper"])
-        
-        content = self.generate_content(idea, format_type, research_data)
-        print(f"[Content Creation Agent]: Generated {format_type} content with {len(content)} characters")
-        
-        # Step 4: Evaluate the content
-        evaluation = self.evaluate_content(content)
-        print(f"[Evaluation Agent]: Content evaluated - Viral Potential: {evaluation['overall_viral_potential']}/10")
-        
-        # Step 5: Improve the content based on evaluation
-        improved_content = self.improve_content(content, evaluation)
-        print(f"[Improvement Agent]: Content improved based on evaluation feedback")
-        
-        # Step 6: Format the content for publication
-        format_requirements = {
-            'include_metadata': True,
-            'include_cta': True,
-            'format': format_type,
-            'title': idea,
-            'tags': ['viral', 'content', 'generated', idea.split()[0] if idea.split() else 'AI']
-        }
-        formatted_content = self.format_content(improved_content, format_requirements)
-        print(f"[Formatting Agent]: Content formatted for publication with metadata")
-        
-        # Step 7: Prepare for publishing
-        publishing_requirements = {
-            'format': format_type,
-            'platform': 'multi-platform',
-            'hashtags': ['#ViralContent', '#AIContent', f'#{idea.split()[0] if idea.split() else "Generated"}']
+
+# ---------------------------
+# Logging
+# ---------------------------
+LOGGER_NAME = "viral_agent"
+logger = logging.getLogger(LOGGER_NAME)
+if not logger.handlers:
+    level = os.getenv("AGENT_LOG_LEVEL", "INFO").upper()
+    logging.basicConfig(level=getattr(logging, level, logging.INFO), format="%(asctime)s %(levelname)s | %(message)s")
+
+# ---------------------------
+# Prompts (kept concise; multi‑line strings)
+# ---------------------------
+PREFIX = (
+    "You are an Advanced Viral Content Generator with self‑research and self‑improvement capabilities.\n"
+    "Tools: GENERATE_IDEA, RESEARCH, GENERATE_CONTENT, SELF_EVALUATE, IMPROVE_CONTENT, FORMAT_CONTENT, PUBLISH, COMPLETE.\n"
+    "Trigger using lines: action: <TOOL> and action_input=<TEXT>.\n"
+)
+
+IDEA_GENERATOR_PROMPT = (
+    "Generate one viral content idea. Consider trending topics, underserved niches, controversy, practical value, and emotion.\n"
+    "Return a single concise title. Topic: {topic}. History: {history}"
+)
+
+RESEARCH_PROMPT = (
+    "You are researching: {topic}. Summarize key facts with bullet points. Include stats with sources when available."
+)
+
+CONTENT_PROMPT = (
+    "Create {format_type} content about: {topic}. Use the following research notes: {research}.\n"
+    "Hook, sections with headings, and a clear wrap‑up. Keep it factual and concise."
+)
+
+EVALUATE_PROMPT = (
+    "Evaluate content quality and viral potential from 1‑10 for engagement, accuracy, originality, emotion, readability, and headline strength.\n"
+    "Return compact JSON with fields per_criterion and overall plus three specific improvements. Content: {content}"
+)
+
+IMPROVE_PROMPT = (
+    "Improve the content using this feedback: {feedback}. Strengthen hook, structure, and specificity. Return the full revised content. Content: {content}"
+)
+
+FORMAT_PROMPT = (
+    "Format the content for publication. Add an SEO title (<70 chars), meta description (<160 chars), h2/h3 where useful, and a short CTA. Content: {content}"
+)
+
+PUBLISH_PROMPT = (
+    "Prepare publication package fields: title, summary, tags[], canonical, published_at (ISO8601 UTC), body. Content: {content}"
+)
+
+# ---------------------------
+# Utilities
+# ---------------------------
+
+def utc_now_iso() -> str:
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+
+def json_dumps(obj: Any) -> str:
+    return json.dumps(obj, ensure_ascii=False, separators=(",", ":"))
+
+
+def clamp_text(s: str, max_len: int = 6000) -> str:
+    if len(s) <= max_len:
+        return s
+    return s[: max(0, max_len - 3)] + "..."
+
+
+# ---------------------------
+# LLM backends
+# ---------------------------
+
+class LLM:
+    def complete(self, prompt: str, max_tokens: int = 800) -> str:
+        raise NotImplementedError
+
+
+class HFInferenceLLM(LLM):
+    """Hugging Face text‑generation inference. Expects env HUGGINGFACE_API_TOKEN and HUGGINGFACE_MODEL."""
+
+    def __init__(self, model: Optional[str] = None, timeout: int = 60):
+        self.token = os.getenv("HUGGINGFACE_API_TOKEN")
+        self.model = model or os.getenv("HUGGINGFACE_MODEL", "gpt2")
+        self.timeout = timeout
+        self.endpoint = f"https://api-inference.huggingface.co/models/{self.model}"
+
+    def complete(self, prompt: str, max_tokens: int = 800) -> str:
+        if not self.token:
+            raise RuntimeError("HUGGINGFACE_API_TOKEN not set")
+        headers = {"Authorization": f"Bearer {self.token}", "Accept": "application/json"}
+        payload = {"inputs": prompt, "parameters": {"max_new_tokens": max_tokens, "return_full_text": False}}
+        r = requests.post(self.endpoint, headers=headers, json=payload, timeout=self.timeout)
+        r.raise_for_status()
+        data = r.json()
+        # Response shape can vary; normalize
+        if isinstance(data, list) and data and "generated_text" in data[0]:
+            return str(data[0]["generated_text"]).strip()
+        if isinstance(data, dict) and "generated_text" in data:
+            return str(data["generated_text"]).strip()
+        # Fallback parsing
+        return json_dumps(data)
+
+
+class OpenAILLM(LLM):
+    """OpenAI responses via /v1/chat/completions. Requires OPENAI_API_KEY and OPENAI_MODEL."""
+
+    def __init__(self, model: Optional[str] = None, timeout: int = 60):
+        self.key = os.getenv("OPENAI_API_KEY")
+        self.model = model or os.getenv("OPENAI_MODEL", "gpt-4o-mini")
+        self.timeout = timeout
+        self.url = os.getenv("OPENAI_BASE_URL", "https://api.openai.com/v1/chat/completions")
+
+    def complete(self, prompt: str, max_tokens: int = 800) -> str:
+        if not self.key:
+            raise RuntimeError("OPENAI_API_KEY not set")
+        headers = {"Authorization": f"Bearer {self.key}", "Content-Type": "application/json"}
+        payload = {
+            "model": self.model,
+            "messages": [{"role": "user", "content": prompt}],
+            "temperature": 0.2,
+            "max_tokens": max_tokens,
         }
-        published_content = self.publish_content(formatted_content, publishing_requirements)
-        print(f"[Publishing Agent]: Content prepared for distribution with manifest")
-        
-        # Add to content history
-        self.content_history.append({
-            'idea': idea,
-            'format_type': format_type,
-            'publish_time': datetime.now().isoformat(),
-            'virality_score': evaluation['overall_viral_potential']
-        })
-        
-        return published_content
-
-
-# Tool mappings for the viral content generator
-TOOLS = {
-    "GENERATE_IDEA": {
-        "function": "generate_idea",
-        "description": "Generate viral content ideas across formats"
-    },
-    "RESEARCH": {
-        "function": "research_topic", 
-        "description": "Research topics for content generation"
-    },
-    "GENERATE_CONTENT": {
-        "function": "generate_content",
-        "description": "Create content in specified format"
-    },
-    "SELF_EVALUATE": {
-        "function": "evaluate_content",
-        "description": "Evaluate content quality and viral potential"
-    },
-    "IMPROVE_CONTENT": {
-        "function": "improve_content",
-        "description": "Improve content based on evaluation"
-    },
-    "FORMAT_CONTENT": {
-        "function": "format_content",
-        "description": "Format content for publication"
-    },
-    "PUBLISH": {
-        "function": "publish_content",
-        "description": "Prepare content for distribution"
-    },
-    "COMPLETE": {
-        "function": "complete_task",
-        "description": "Mark task as complete"
+        r = requests.post(self.url, headers=headers, json=payload, timeout=self.timeout)
+        r.raise_for_status()
+        data = r.json()
+        return data["choices"][0]["message"]["content"].strip()
+
+
+class GenericHTTPJSONLLM(LLM):
+    """POSTs to LLM_ENDPOINT with JSON {prompt,max_tokens}. Expects plain text in response body or JSON {text:...}."""
+
+    def __init__(self, endpoint: Optional[str] = None, timeout: int = 60):
+        self.endpoint = endpoint or os.getenv("LLM_ENDPOINT")
+        self.timeout = timeout
+
+    def complete(self, prompt: str, max_tokens: int = 800) -> str:
+        if not self.endpoint:
+            raise RuntimeError("LLM_ENDPOINT not set")
+        r = requests.post(self.endpoint, json={"prompt": prompt, "max_tokens": max_tokens}, timeout=self.timeout)
+        r.raise_for_status()
+        try:
+            data = r.json()
+            return str(data.get("text") or data.get("output") or data).strip()
+        except Exception:
+            return r.text.strip()
+
+
+class RuleBasedLLM(LLM):
+    """Offline, deterministic fallback. Produces concise templates to keep the pipeline functional without keys."""
+
+    def complete(self, prompt: str, max_tokens: int = 800) -> str:
+        # Very small heuristics to keep output useful and testable
+        if "Generate one viral content idea" in prompt:
+            return "AI Side‑Hustles in 2025: 11 Practical Plays That Actually Work"
+        if "You are researching" in prompt:
+            topic = re.search(r"researching:\s*(.+?)\.\s*Summarize", prompt)
+            t = topic.group(1) if topic else "the topic"
+            return (
+                f"- Definition and scope of {t}\n"
+                f"- 2024–2025 trendline and adoption\n"
+                f"- 3 data points with sources\n"
+                f"- Risks, regulation, and future outlook"
+            )
+        if "Evaluate content quality" in prompt:
+            return json_dumps({
+                "per_criterion": {
+                    "engagement": 8, "accuracy": 7, "originality": 7,
+                    "emotion": 7, "readability": 8, "headline": 7,
+                },
+                "overall": 7.5,
+                "improvements": [
+                    "Tighten hook with concrete stat",
+                    "Add one contrarian insight",
+                    "Replace generic CTA with a next‑step checklist",
+                ],
+            })
+        if "Improve the content" in prompt:
+            return "[Improved] " + clamp_text(prompt.split("Content:", 1)[-1].strip())
+        if "Format the content for publication" in prompt:
+            return (
+                "SEO Title: Practical AI Side‑Hustles for 2025\n"
+                "Meta: A concise guide with data, risks, and an action checklist.\n"
+                "\n## Introduction\n...\n\n## CTA\nGrab the checklist."
+            )
+        if "Prepare publication package" in prompt:
+            now = utc_now_iso()
+            return json_dumps({
+                "title": "Practical AI Side‑Hustles for 2025",
+                "summary": "Concise, data‑guided ideas with risks and a checklist.",
+                "tags": ["AI", "side‑hustle", "2025"],
+                "canonical": "",
+                "published_at": now,
+                "body": "...",
+            })
+        # Default short echo
+        return clamp_text("[draft] " + prompt[-max_tokens:])
+
+
+def build_llm() -> LLM:
+    # Order of preference: explicit endpoint, OpenAI, HF, fallback
+    try:
+        if os.getenv("LLM_ENDPOINT"):
+            logger.info("Using GenericHTTPJSONLLM")
+            return GenericHTTPJSONLLM()
+        if os.getenv("OPENAI_API_KEY"):
+            logger.info("Using OpenAILLM")
+            return OpenAILLM()
+        if os.getenv("HUGGINGFACE_API_TOKEN"):
+            logger.info("Using HFInferenceLLM")
+            return HFInferenceLLM()
+    except Exception as e:
+        logger.warning("LLM backend init failed, falling back: %s", e)
+    logger.info("Using RuleBasedLLM fallback")
+    return RuleBasedLLM()
+
+
+# ---------------------------
+# Research utilities
+# ---------------------------
+
+def ddg_search_snippets(query: str, limit: int = 5, timeout: int = 15) -> List[Dict[str, str]]:
+    """Very light HTML scrape of DuckDuckGo HTML to avoid heavy APIs. Returns [{title,url,snippet}]"""
+    try:
+        url = "https://html.duckduckgo.com/html/"
+        r = requests.post(url, data={"q": query}, timeout=timeout, headers={"User-Agent": "agent/1.0"})
+        r.raise_for_status()
+        html = r.text
+        # naive parsing
+        results = []
+        for m in re.finditer(r'<a[^>]+class="result__a"[^>]*href=\"([^\"]+)\"[^>]*>(.*?)</a>', html):
+            link = m.group(1)
+            title = re.sub("<.*?>", "", m.group(2))
+            results.append({"title": title, "url": link, "snippet": ""})
+            if len(results) >= limit:
+                break
+        return results
+    except Exception as e:
+        logger.warning("ddg_search_snippets failed: %s", e)
+        return []
+
+
+def wikipedia_summary(topic: str, timeout: int = 15) -> Optional[str]:
+    try:
+        api = "https://en.wikipedia.org/api/rest_v1/page/summary/" + requests.utils.quote(topic)
+        r = requests.get(api, timeout=timeout, headers={"User-Agent": "agent/1.0"})
+        if r.status_code == 200:
+            data = r.json()
+            return data.get("extract")
+    except Exception as e:
+        logger.warning("wikipedia_summary failed: %s", e)
+    return None
+
+
+# ---------------------------
+# Tools
+# ---------------------------
+
+@dataclass
+class AgentHistory:
+    items: List[str] = field(default_factory=list)
+
+    def add(self, line: str) -> None:
+        self.items.append(line)
+
+    def render(self, max_len: int = 4000) -> str:
+        text = "\n".join(self.items)
+        return clamp_text(text, max_len)
+
+
+@dataclass
+class AgentConfig:
+    seed: int = 42
+    max_loops: int = 8
+    max_tokens: int = 800
+    log_jsonl: Optional[str] = os.getenv("AGENT_LOG_JSONL")
+
+
+class ViralAgent:
+    ALLOWED_TOOLS = {
+        "GENERATE_IDEA",
+        "RESEARCH",
+        "GENERATE_CONTENT",
+        "SELF_EVALUATE",
+        "IMPROVE_CONTENT",
+        "FORMAT_CONTENT",
+        "PUBLISH",
+        "COMPLETE",
     }
-}
-
-# Original constants for compatibility with app.py
-COMPRESS_HISTORY_PROMPT = """
-You are attempting to complete the task
-task: {task}
-Progress:
-{history}
-Compress the timeline of progress above 
-"""
 
-LOG_PROMPT = """
-PROMPT
-**************************************
-{}
-**************************************
-"""
-
-LOG_RESPONSE = """
-RESPONSE
-**************************************
-{}
-**************************************
-"""
-
-# Additional prompts for compatibility
-ADD_PROMPT = """
-You are attempting to complete the task
-task: {task}
-Progress:
-{history}
-Write a new file called {file_path} with contents between ---
-After the contents write a paragraph on what was inserted with details
-"""
-
-MODIFY_PROMPT = """
-You are attempting to complete the task
-task: {task}
-Progress:
-{history}
-{file_path}
----
-{file_contents}
----
-Return the complete modified {file_path} contents between ---
-After the contents write a paragraph on what was changed with details
-"""
-
-READ_PROMPT = """
-You are attempting to complete the task
-task: {task}
-Progress:
-{history}
-{file_path}
----
-{file_contents}
----
-Return your thoughts about the file relevant to completing the task (in a paragraph)
-Mention any specific functions, arguments, or details needed
-"""
-
-UNDERSTAND_TEST_RESULTS_PROMPT = """
-You are attempting to complete the task
-task: {task}
-Progress:
-{history}
-Test results:
-STDOUT
----
-{stdout}
----
-STDERR
----
-{stderr}
----
-Describe why the tests failed and how to fix them (in a paragraph)
-"""
+    def __init__(self, llm: Optional[LLM] = None, cfg: Optional[AgentConfig] = None):
+        self.llm = llm or build_llm()
+        self.cfg = cfg or AgentConfig()
+        random.seed(self.cfg.seed)
+        self.history = AgentHistory()
+        self.session_id = uuid.uuid4().hex[:8]
+        logger.info("session=%s seed=%s", self.session_id, self.cfg.seed)
+
+    # -------- action loop --------
+    ACTION_RE = re.compile(r"^\s*action:\s*([A-Z_]+)\s*\naction_input=(.*)", re.S)
+
+    def run(self, task: str, purpose: str = "Generate viral content") -> Dict[str, Any]:
+        self.history.add(f"task: {task}")
+        context = PREFIX + f"Current Date/Time: {utc_now_iso()}\nPurpose: {purpose}\n"
+
+        for step in range(1, self.cfg.max_loops + 1):
+            prompt = (
+                f"{context}\nHistory:\n{self.history.render()}\n\n"
+                "Decide next step. Output exactly two lines:\n"
+                "action: <TOOL>\n"
+                "action_input=<TEXT>\n"
+            )
+            raw = self.llm.complete(prompt, max_tokens=self.cfg.max_tokens)
+            tool, payload = self._parse_action(raw)
+            logger.info("step=%s tool=%s", step, tool)
+            obs = self._dispatch(tool, payload, task)
+            self.history.add(f"observation: {clamp_text(obs, 800)}")
+            if tool == "COMPLETE":
+                return {"status": "ok", "session": self.session_id, "history": self.history.items}
+        return {"status": "max_loops", "session": self.session_id, "history": self.history.items}
+
+    # -------- parsing and dispatch --------
+    def _parse_action(self, text: str) -> Tuple[str, str]:
+        m = self.ACTION_RE.search(text or "")
+        if not m:
+            logger.warning("action parse failed; default to GENERATE_IDEA")
+            return "GENERATE_IDEA", "general tech trends 2025"
+        tool = m.group(1).strip().upper()
+        payload = m.group(2).strip()
+        if tool not in self.ALLOWED_TOOLS:
+            logger.warning("tool not allowed: %s", tool)
+            tool = "GENERATE_IDEA"
+        # guard payload
+        payload = clamp_text(payload, 4000)
+        return tool, payload
+
+    def _dispatch(self, tool: str, payload: str, task: str) -> str:
+        if tool == "GENERATE_IDEA":
+            idea = self.generate_idea(task, payload)
+            self.history.add(f"thought: generated idea -> {idea}")
+            return idea
+        if tool == "RESEARCH":
+            notes = self.research(payload or task)
+            self.history.add("thought: researched topic")
+            return notes
+        if tool == "GENERATE_CONTENT":
+            fmt = self._guess_format(payload)
+            notes = self._latest_research() or "key facts unavailable"
+            content = self.generate_content(task, fmt, notes)
+            self.history.add("thought: drafted content")
+            return content
+        if tool == "SELF_EVALUATE":
+            content = self._latest_content() or payload
+            return self.evaluate(content)
+        if tool == "IMPROVE_CONTENT":
+            content, feedback = self._split_two(payload)
+            improved = self.improve(content, feedback)
+            self.history.add("thought: improved content")
+            return improved
+        if tool == "FORMAT_CONTENT":
+            return self.format_content(payload)
+        if tool == "PUBLISH":
+            return self.publish(payload)
+        if tool == "COMPLETE":
+            return "done"
+        return "noop"
+
+    # -------- tool implementations --------
+    def generate_idea(self, topic: str, description: str) -> str:
+        p = IDEA_GENERATOR_PROMPT.format(topic=topic or description, history=self.history.render())
+        return self.llm.complete(p, max_tokens=120)
+
+    def research(self, topic: str) -> str:
+        topic = topic or "general topic"
+        bullets = []
+        # Try Wikipedia summary
+        s = wikipedia_summary(topic)
+        if s:
+            bullets.append("Wikipedia summary: " + s)
+        # Try DDG snippets
+        for r in ddg_search_snippets(topic, limit=5):
+            bullets.append(f"- {r['title']} — {r['url']}")
+        # LLM consolidation
+        prompt = RESEARCH_PROMPT.format(topic=topic)
+        llm_notes = self.llm.complete(prompt, max_tokens=200)
+        bullets.append(llm_notes)
+        notes = "\n".join(bullets)
+        # persist short log row
+        self._log_jsonl({"t": utc_now_iso(), "event": "research", "topic": topic, "notes": clamp_text(notes, 2000)})
+        return notes
+
+    def _guess_format(self, s: str) -> str:
+        s = s.lower()
+        for key in ["blog", "book", "review", "paper", "newsletter", "social"]:
+            if key in s:
+                return {
+                    "blog": "blog_article",
+                    "book": "book_chapter",
+                    "review": "review_article",
+                    "paper": "academic_paper",
+                    "newsletter": "newsletter",
+                    "social": "social_media_post",
+                }[key]
+        return "blog_article"
+
+    def generate_content(self, topic: str, format_type: str, research: str) -> str:
+        p = CONTENT_PROMPT.format(topic=topic, format_type=format_type, research=clamp_text(research, 2000))
+        content = self.llm.complete(p, max_tokens=700)
+        self._log_jsonl({"t": utc_now_iso(), "event": "content", "format": format_type, "len": len(content)})
+        return content
+
+    def evaluate(self, content: str) -> str:
+        p = EVALUATE_PROMPT.format(content=clamp_text(content, 2500))
+        out = self.llm.complete(p, max_tokens=220)
+        # validate JSON when possible
+        try:
+            obj = json.loads(out)
+            if isinstance(obj, dict):
+                out = json_dumps(obj)
+        except Exception:
+            pass
+        self._log_jsonl({"t": utc_now_iso(), "event": "evaluate"})
+        return out
+
+    def improve(self, content: str, feedback: str) -> str:
+        p = IMPROVE_PROMPT.format(content=clamp_text(content, 2500), feedback=clamp_text(feedback, 800))
+        out = self.llm.complete(p, max_tokens=700)
+        self._log_jsonl({"t": utc_now_iso(), "event": "improve"})
+        return out
+
+    def format_content(self, content: str) -> str:
+        p = FORMAT_PROMPT.format(content=clamp_text(content, 2500))
+        out = self.llm.complete(p, max_tokens=300)
+        self._log_jsonl({"t": utc_now_iso(), "event": "format"})
+        return out
+
+    def publish(self, content: str) -> str:
+        p = PUBLISH_PROMPT.format(content=clamp_text(content, 2000))
+        out = self.llm.complete(p, max_tokens=220)
+        # ensure minimal JSON shape
+        try:
+            obj = json.loads(out)
+            if "published_at" not in obj:
+                obj["published_at"] = utc_now_iso()
+            out = json_dumps(obj)
+        except Exception:
+            # wrap as minimal manifest
+            out = json_dumps({"title": "Untitled", "summary": "", "tags": [], "canonical": "", "published_at": utc_now_iso(), "body": out})
+        self._log_jsonl({"t": utc_now_iso(), "event": "publish"})
+        return out
+
+    # -------- helpers --------
+    def _split_two(self, block: str) -> Tuple[str, str]:
+        parts = block.split("\n\n", 1)
+        if len(parts) == 2:
+            return parts[0].strip(), parts[1].strip()
+        return block, ""
+
+    def _latest_research(self) -> Optional[str]:
+        for line in reversed(self.history.items):
+            if line.startswith("observation:") and ("Wikipedia summary:" in line or line.strip().startswith("- ")):
+                return line.split("observation:", 1)[-1].strip()
+        return None
+
+    def _latest_content(self) -> Optional[str]:
+        for line in reversed(self.history.items):
+            if line.startswith("observation:") and len(line) > 30 and ("##" in line or "#" in line or "\n" in line):
+                return line.split("observation:", 1)[-1].strip()
+        return None
+
+    def _log_jsonl(self, row: Dict[str, Any]) -> None:
+        path = self.cfg.log_jsonl
+        if not path:
+            return
+        try:
+            with open(path, "a", encoding="utf-8") as f:
+                f.write(json_dumps(row) + "\n")
+        except Exception as e:
+            logger.warning("jsonl log failed: %s", e)
+
+
+# ---------------------------
+# CLI
+# ---------------------------
+
+def run_cli() -> None:
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Viral content agent")
+    parser.add_argument("task", help="Task to execute, e.g., 'Write a blog about X'")
+    parser.add_argument("--purpose", default="Generate viral content")
+    parser.add_argument("--seed", type=int, default=int(os.getenv("AGENT_SEED", "42")))
+    parser.add_argument("--max-loops", type=int, default=int(os.getenv("AGENT_MAX_LOOPS", "6")))
+    parser.add_argument("--log-jsonl", default=os.getenv("AGENT_LOG_JSONL"))
+    args = parser.parse_args()
+
+    cfg = AgentConfig(seed=args.seed, max_loops=args.max_loops, log_jsonl=args.log_jsonl)
+    agent = ViralAgent(cfg=cfg)
+    result = agent.run(task=args.task, purpose=args.purpose)
+    print(json_dumps(result))
+
+
+if __name__ == "__main__":
+    run_cli()