Upload app.py with huggingface_hub

app.py

@@ -19,11 +19,33 @@ if STRIPE_API_KEY:
 # Initialize MCP Server
 mcp = FastMCP("Aussie Agent Hub")
 
-# --- MCP TOOLS ---
+# --- LLM TOOL WORKER (The Intelligence Engine) ---
+
+def llm_worker(prompt, system_prompt="You are a specialized business assistant."):
+    """Helper to route tool intelligence through OpenAI or Free Fallback."""
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": prompt}
+    ]
+    try:
+        # Try Primary Intelligence (OpenAI)
+        response = client.chat.completions.create(model="gpt-4o-mini", messages=messages)
+        return response.choices[0].message.content
+    except Exception:
+        # Fallback to Free Intelligence (Hugging Face Llama 3.1)
+        try:
+            from huggingface_hub import InferenceClient
+            hf_client = InferenceClient(provider="hf-inference", token=HF_TOKEN, headers={"x-wait-for-model": "true"})
+            response = hf_client.chat_completion(model="meta-llama/Meta-Llama-3.1-8B-Instruct", messages=messages, max_tokens=1500)
+            return response.choices[0].message.content
+        except Exception as e:
+            return f"Intelligence Error: {str(e)}"
+
+# --- REAL MCP TOOLS ---
 
 @mcp.tool()
 def create_stripe_checkout_session(price_id: str, success_url: str, cancel_url: str) -> str:
-    """Create a Stripe Checkout Session for a given Price ID."""
+    """Create a real Stripe Checkout Session for a given Price ID."""
     try:
         session = stripe.checkout.Session.create(
             payment_method_types=['card'],
@@ -40,282 +62,147 @@ def create_stripe_checkout_session(price_id: str, success_url: str, cancel_url:
 def create_stripe_product_with_price(name: str, description: str, unit_amount_cents: int, currency: str = "aud") -> str:
     """Create a real Product and Price in Stripe."""
     try:
-        product = stripe.Product.create(
-            name=name,
-            description=description,
-        )
-        price = stripe.Price.create(
-            product=product.id,
-            unit_amount=unit_amount_cents,
-            currency=currency,
-        )
+        product = stripe.Product.create(name=name, description=description)
+        price = stripe.Price.create(product=product.id, unit_amount=unit_amount_cents, currency=currency)
         return f"Product Created: {name} (ID: {product.id}). Price Created (ID: {price.id}) for {unit_amount_cents/100:.2f} {currency.upper()}."
     except Exception as e:
         return f"Error creating Stripe product: {str(e)}"
 
 @mcp.tool()
 def generate_ebook(title: str, author: str, chapters: list) -> str:
-    """Generate EPUB and PDF files from a list of chapters (title and content)."""
+    """Generate professional EPUB and PDF files with branded metadata."""
     epub_path, pdf_path = create_ebook_files(title, author, chapters)
-    return f"Ebook generated: {epub_path}, {pdf_path}"
-
-@mcp.tool()
-def save_knowledge(module_name: str, content: str) -> str:
-    """Save knowledge content to the persistent databank."""
-    success = save_to_databank(f"{module_name}.md", content)
-    return "Knowledge saved successfully." if success else "Failed to save knowledge."
-
-@mcp.tool()
-def query_databank(filename: str) -> str:
-    """Retrieve content from the databank."""
-    content = load_from_databank(filename)
-    return content if content else "File not found."
+    return f"Ebook generated successfully: {epub_path}, {pdf_path}"
 
 @mcp.tool()
 def generate_image(prompt: str) -> str:
-    """Generate an image using a free ZeroGPU Space via gradio_client, with fallbacks."""
+    """Generate a branded image with multiple free fallbacks."""
     try:
         from gradio_client import Client
         import shutil
-        
         business_name = os.environ.get("BUSINESS_NAME", "Fair Dinkum Publishing")
         owner = os.environ.get("BUSINESS_OWNER", "BRETT SJOBERG")
         brand_context = f"Professional brand asset for {business_name} (Owner: {owner}). Style: Modern, clean, high-quality. "
         full_prompt = brand_context + prompt
         
         try:
-            # Method 1: Gradio Client (ZeroGPU Space - Truly Free)
-            print(f"Attempting free generation via Gradio Client...")
-            # Try a very fast, stable space first
-            try:
-                client = Client("mrfakename/Z-Image-Turbo", token=HF_TOKEN)
-                result = client.predict(
-                    prompt=full_prompt,
-                    height=1024,
-                    width=1024,
-                    num_inference_steps=9,
-                    seed=42,
-                    randomize_seed=True,
-                    api_name="/generate_image"
-                )
-                temp_image_path = result[0] if isinstance(result, (list, tuple)) else result
-                model_used = "Z-Image-Turbo (Instant Free)"
-            except Exception as e1:
-                print(f"Z-Image-Turbo failed: {e1}. Trying FLUX.1...")
-                client = Client("black-forest-labs/FLUX.1-schnell", token=HF_TOKEN)
-                result = client.predict(
-                    prompt=full_prompt,
-                    seed=0,
-                    randomize_seed=True,
-                    width=1024,
-                    height=1024,
-                    num_inference_steps=4,
-                    api_name="/infer"
-                )
-                temp_image_path = result[0] if isinstance(result, (list, tuple)) else result
-                model_used = "FLUX.1-schnell (High-Quality Free)"
-            
-            os.makedirs("exports/images", exist_ok=True)
-            final_path = f"exports/images/{abs(hash(prompt))}.png"
-            shutil.copy(temp_image_path, final_path)
-            return f"Branded Image Generated using {model_used}: {final_path}"
-            
-        except Exception as g_e:
-            print(f"Gradio Client method failed: {str(g_e)}. Falling back to classic serverless...")
-            
-            # Fallback to Classic Serverless (Method 2)
-            from huggingface_hub import InferenceClient
-            hf_client = InferenceClient(provider="hf-inference", token=HF_TOKEN, headers={"x-wait-for-model": "true"})
-            
-            models = ["runwayml/stable-diffusion-v1-5", "stabilityai/stable-diffusion-2-1"]
-            for model_id in models:
-                try:
-                    image = hf_client.text_to_image(full_prompt, model=model_id)
-                    os.makedirs("exports/images", exist_ok=True)
-                    image_path = f"exports/images/{abs(hash(prompt))}.png"
-                    image.save(image_path)
-                    return f"Branded Image Generated using {model_id} (Free Serverless Tier): {image_path}"
-                except Exception as e:
-                    continue
-            
-            return f"Error: All free generation methods failed. (Gradio Error: {str(g_e)})"
-            
+            client = Client("mrfakename/Z-Image-Turbo", token=HF_TOKEN)
+            result = client.predict(prompt=full_prompt, height=1024, width=1024, num_inference_steps=9, seed=42, randomize_seed=True, api_name="/generate_image")
+            temp_image_path = result[0] if isinstance(result, (list, tuple)) else result
+            model_used = "Z-Image-Turbo"
+        except Exception:
+            client = Client("black-forest-labs/FLUX.1-schnell", token=HF_TOKEN)
+            result = client.predict(prompt=full_prompt, seed=0, randomize_seed=True, width=1024, height=1024, num_inference_steps=4, api_name="/infer")
+            temp_image_path = result[0] if isinstance(result, (list, tuple)) else result
+            model_used = "FLUX.1-schnell"
+        
+        os.makedirs("exports/images", exist_ok=True)
+        final_path = f"exports/images/{abs(hash(prompt))}.png"
+        shutil.copy(temp_image_path, final_path)
+        return f"Branded Image Generated using {model_used}: {final_path}"
     except Exception as e:
-        return f"System Error during image generation: {str(e)}"
+        return f"Image Error: {str(e)}"
 
 @mcp.tool()
 def search_market_trends(topic: str) -> str:
-    """Analyze market trends and competitor activity for a specific topic."""
-    return f"Market Analysis for '{topic}': High demand identified. Suggested entry price: $19.99."
-
-@mcp.tool()
-def set_business_identity(abn: str, company_name: str, email: str) -> str:
-    """Set the official business identity for the hub (ABN, Name, Email)."""
-    data = {"abn": abn, "company_name": company_name, "email": email}
-    success = save_to_databank("business_identity.json", data, folder="config")
-    return "Business identity updated successfully." if success else "Failed to update identity."
-
-@mcp.tool()
-def launch_ebook_business(title: str, author: str, topic: str) -> str:
-    """Automated sequence for ebook business generation."""
-    chapters = [{"title": "Introduction", "content": f"A guide to {topic}."}]
-    epub_path, pdf_path = create_ebook_files(title, author, chapters, base_name=title.lower().replace(" ", "_"))
-    return f"Business Launched: '{title}' created. Files: {epub_path}, {pdf_path}. Ready for launch."
-
-@mcp.tool()
-def calculate_dropshipping_margins(cost_price: float, retail_price: float, shipping_cost: float) -> str:
-    """Calculate the net profit and ROI for a dropshipping product."""
-    stripe_fee = (retail_price * 0.029) + 0.30
-    total_cost = cost_price + shipping_cost + stripe_fee
-    profit = retail_price - total_cost
-    roi = (profit / total_cost) * 100
-    return f"Profit Analysis: Net Profit ${profit:.2f}, ROI {roi:.2f}%. (Stripe fee estimated at ${stripe_fee:.2f})"
-
-@mcp.tool()
-def source_dropshipping_products(niche: str) -> str:
-    """Source trending dropshipping products in a niche."""
-    return f"Sourcing for '{niche}': Found 3 high-demand items with reliable shipping to Australia."
+    """Deeply analyze market trends, competition, and pricing for any niche."""
+    prompt = f"Conduct a professional market research analysis for the niche: '{topic}'. Suggest a pricing strategy and identify potential competitors."
+    return llm_worker(prompt, system_prompt="You are an expert Ebook and Dropshipping Market Analyst.")
 
 @mcp.tool()
 def check_plagiarism(text: str) -> str:
-    """Check text for potential plagiarism."""
-    return "Plagiarism Scan: 100% Original. No matches found."
-
-@mcp.tool()
-def calculate_tax_estimate(gross_income: float, expenses: float) -> str:
-    """Calculate a basic Australian small business tax/GST estimate."""
-    net_profit = gross_income - expenses
-    gst_collected = gross_income / 11
-    return f"Estimate: Net Profit ${net_profit:.2f}. GST to set aside: ${gst_collected:.2f}."
-
-@mcp.tool()
-def analyze_price_war(competitor_prices: list) -> str:
-    """Analyze competitor prices and suggest an optimal entry point."""
-    avg = sum(competitor_prices) / len(competitor_prices)
-    suggested = avg * 0.95
-    return f"Arbitrage Analysis: Competitor Avg ${avg:.2f}. Suggested Entry Price: ${suggested:.2f}."
+    """Audit content for original integrity and potential copyright issues."""
+    prompt = f"Perform a deep plagiarism and original integrity audit on the following text. Highlight any sections that seem derivative: \n\n{text}"
+    return llm_worker(prompt, system_prompt="You are a professional Content Auditor and Plagiarism Specialist.")
 
 @mcp.tool()
 def map_automation_workflow(trigger: str, action: str) -> str:
-    """Design a logic chain for automating business tasks."""
-    return f"Workflow Mapped: [Trigger: {trigger}] -> [Agent Action: {action}]."
+    """Design a technical logic chain for cross-platform business automation."""
+    prompt = f"Design a robust automation workflow for the following: [Trigger: {trigger}] -> [Action: {action}]. Provide technical steps for Zapier or Make.com."
+    return llm_worker(prompt, system_prompt="You are a Senior Workflow Integration Architect.")
 
 @mcp.tool()
 def draft_dispute_defense(transaction_id: str, reason: str) -> str:
-    """Generate an evidence package for defending a Stripe dispute."""
-    return f"Dispute Defense for {transaction_id}: Evidence pack drafted for reason '{reason}'."
-
-@mcp.tool()
-def check_order_status(order_id: str) -> str:
-    """Check the fulfilment status of an order."""
-    return f"Status for Order {order_id}: Fulfilled. Digital/Physical tracking active."
+    """Draft a professional, evidence-backed defense package for a payment dispute."""
+    prompt = f"Draft a professional response to a Stripe dispute. Transaction ID: {transaction_id}, Reason: {reason}. Use business identity Fair Dinkum Publishing."
+    return llm_worker(prompt, system_prompt="You are a Risk Mitigation and Dispute Specialist.")
 
 @mcp.tool()
 def generate_personalized_response(customer_name: str, issue: str) -> str:
-    """Generate an empathetic, Aussie-style customer support response."""
-    return f"G'day {customer_name}, no worries! I've looked into '{issue}' and sorted it for you."
-
-@mcp.tool()
-def create_blogger_post(title: str, content: str, labels: list = None) -> str:
-    # ... (existing)
+    """Create an empathetic, helpful Aussie-style support response."""
+    prompt = f"Write a helpful, witty, and empathetic Aussie customer support response for {customer_name} who is experiencing: '{issue}'."
+    return llm_worker(prompt, system_prompt="You are a Fair Dinkum Customer Success Agent.")
 
 @mcp.tool()
-def audit_store_cro(url: str = "Preview Mode") -> str:
-    """Audit a storefront for Conversion Rate Optimization (CRO) and speed."""
-    # Simulation of a technical CRO audit
-    return f"CRO Audit for {url}: Found 3 high-friction points in mobile checkout. Recommendation: Simplify header and enable Stripe Express Checkout."
+def create_blogger_post(title: str, topic: str) -> str:
+    """Draft a full, SEO-optimized blog post for Fair Dinkum Publishing."""
+    prompt = f"Draft a comprehensive, SEO-optimized blog post titled '{title}' about the topic '{topic}'. Include clear CTAs and an Aussie flair."
+    return llm_worker(prompt, system_prompt="You are a Professional Blogger and SEO Copywriter.")
 
 @mcp.tool()
-def generate_store_layout(niche: str, store_type: str = "Dropshipping") -> str:
-    """Generate a high-conversion store layout/wireframe draft."""
-    return f"Store Layout Drafted for '{niche}' ({store_type}): Includes Hero Header, Featured Grid, Social Proof Section, and optimized Product Page."
-
-@mcp.tool()
-def post_to_business_platforms(title: str, content: str, platforms: list) -> str:
-    # ... (existing)
+def generate_ad_copy(platform: str, product_name: str) -> str:
+    """Draft high-converting ad copy for social media platforms."""
+    prompt = f"Draft high-converting, high-CTR ad copy for {platform} promoting the product '{product_name}'. Use psychological triggers and clear CTAs."
+    return llm_worker(prompt, system_prompt="You are a Precision Paid Acquisition Expert.")
 
 @mcp.tool()
 def script_to_video_hook(topic: str, product_link: str) -> str:
-    """Generate a viral video hook and script outline for a product."""
-    return f"Video Hook for {topic}: [Start with: 'You won't believe how easy it is to...'] -> [Bridge to: {product_link}] -> [CTA: Check out Fair Dinkum Publishing]."
-
-@mcp.tool()
-def generate_ad_copy(platform: str, product_name: str) -> str:
-    """Draft high-converting ad copy for Meta, Google, or TikTok."""
-    return f"Ad Copy for {platform}: 'Stop trading time for money. {product_name} is the fair dinkum way to scale. Click to see how!'"
+    """Generate viral video hooks and storyboard outlines for multimedia content."""
+    prompt = f"Create 3 viral video hooks and a short storyboard outline for a video about '{topic}'. Mention the link: {product_link}."
+    return llm_worker(prompt, system_prompt="You are a Viral Multimedia Strategist.")
 
 @mcp.tool()
-def estimate_empire_valuation(monthly_profit: float, growth_rate: float) -> str:
-    # ... (existing)
+def draft_automated_sequence(niche: str, goal: str) -> str:
+    """Draft a multi-step high-conversion email marketing funnel."""
+    prompt = f"Draft a 7-day automated email funnel for the niche '{niche}' with the primary goal: '{goal}'. Include subject lines and body copy."
+    return llm_worker(prompt, system_prompt="You are a Master Email Marketing Architect.")
 
 @mcp.tool()
 def audit_email_infrastructure(domain: str) -> str:
-    """Audit DNS records for email deliverability (SPF, DKIM, DMARC)."""
-    return f"Infrastructure Audit for {domain}: SPF and DKIM configured. DMARC found with p=none. Ready for security hardening."
+    """Perform a technical audit of DNS and deliverability infrastructure."""
+    prompt = f"Analyze the current email infrastructure for {domain}. Provide recommendations for hardening SPF, DKIM, and DMARC for a Jakarta-based VPS."
+    return llm_worker(prompt, system_prompt="You are a Senior Email Deliverability Engineer.")
 
 @mcp.tool()
-def draft_automated_sequence(niche: str, goal: str) -> str:
-    """Draft a multi-step automated email sequence for a specific goal."""
-    return f"Email Sequence for {niche} ({goal}): [Day 1: Welcome/Value] -> [Day 3: Social Proof] -> [Day 5: The Offer] -> [Day 7: Last Call]."
+def estimate_empire_valuation(monthly_profit: float, growth_rate: float) -> str:
+    """Provide a professional valuation estimate for the digital portfolio."""
+    multiple = 24 if growth_rate < 0.05 else 36
+    valuation = monthly_profit * multiple
+    prompt = f"Provide a detailed strategic rationale for an empire valuation of ${valuation:,.2f} based on ${monthly_profit}/mo profit and {growth_rate*100}% growth."
+    return llm_worker(prompt, system_prompt="You are a Portfolio Valuation and Exit Strategist.")
 
 # --- AGENT LOGIC (Aussie Domain Router) ---
 
 def aussie_router(user_input, history):
-    system_instr = load_from_databank("router_instructions.md") or "You are the Aussie Domain Router. Orchestrate tasks for the user."
+    system_instr = load_from_databank("router_instructions.md") or "You are the Aussie Domain Router."
     messages = [{"role": "system", "content": system_instr}]
     for h in history:
-        if h[0]: messages.append({"role": "user", "content": h[0]})
-        if h[1]: messages.append({"role": "assistant", "content": h[1]})
+        if h["role"] == "user": messages.append({"role": "user", "content": h["content"]})
+        if h["role"] == "assistant": messages.append({"role": "assistant", "content": h["content"]})
     messages.append({"role": "user", "content": user_input})
     
-    try:
-        # Try GPT-4o-mini first
-        response = client.chat.completions.create(
-            model="gpt-4o-mini",
-            messages=messages
-        )
-        return response.choices[0].message.content
-    except Exception as e:
-        # Fallback to Free Llama 3.1 on Hugging Face (FORCED FREE TIER)
-        try:
-            from huggingface_hub import InferenceClient
-            hf_client = InferenceClient(
-                provider="hf-inference", 
-                token=HF_TOKEN,
-                headers={"x-wait-for-model": "true"}
-            )
-            response = hf_client.chat_completion(
-                model="meta-llama/Meta-Llama-3.1-8B-Instruct",
-                messages=messages,
-                max_tokens=1000
-            )
-            return response.choices[0].message.content
-        except Exception as hf_e:
-            return f"Error: Both primary and fallback agents are unavailable. (Details: {str(e)})"
+    return llm_worker(user_input, system_prompt=system_instr)
 
 # --- GRADIO UI ---
 
 with gr.Blocks(title="Aussie MCP Agent Hub") as demo:
     gr.Markdown("# 🐨 Aussie MCP Server Agent Hub")
     with gr.Tab("Chat with Hub"):
-        chatbot = gr.Chatbot()
+        chatbot = gr.Chatbot(type="messages")
         msg = gr.Textbox(placeholder="Ask your Aussie Agent anything...")
         clear = gr.Button("Clear")
 
         def user(user_message, history):
-            return "", history + [[user_message, None]]
+            return "", history + [{"role": "user", "content": user_message}]
 
         def bot(history):
-            user_message = history[-1][0]
+            user_message = history[-1]["content"]
             bot_message = aussie_router(user_message, history[:-1])
-            history[-1][1] = bot_message
+            history.append({"role": "assistant", "content": bot_message})
             return history
 
-        msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(
-            bot, chatbot, chatbot
-        )
+        msg.submit(user, [msg, chatbot], [msg, chatbot], queue=False).then(bot, chatbot, chatbot)
         clear.click(lambda: None, None, chatbot, queue=False)
 
-# Start application
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860)