AI Integration with Gemini

import os
from dotenv import load_dotenv
from google import genai

load_dotenv()

# Setup Gemini client
GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
if not GEMINI_API_KEY:
    raise ValueError("Missing GEMINI_API_KEY in environment")

client = genai.Client(api_key=GEMINI_API_KEY)

# Default model (can override in function calls)
DEFAULT_MODEL = os.getenv("MODEL_ID", "gemini-2.5-flash")

def ask_gemini(prompt: str, model: str = DEFAULT_MODEL) -> str:
    """
    Ask Gemini a question and return plain text.
    """
    return _call_gemini(prompt, model)

def ask_gemini_as_xml(
    prompt: str, model: str = DEFAULT_MODEL, root_tag: str = "Response"
) -> str:
    """
    Ask Gemini and wrap the response inside an XML response.
    Useful for USSD/Voice APIs.
    """
    text = _call_gemini(prompt, model)
    xml = f'<?xml version="1.0" encoding="UTF-8"?>\n<{root_tag}>\n  <Say>{text}</Say>\n</{root_tag}>'
    return xml

def ask_gemini_structured(
    prompt: str, model: str = DEFAULT_MODEL, output_format: str = "json"
) -> str:
    """
    Ask Gemini and request a structured response.
    Output format can be 'json', 'xml', or any custom instruction.
    """
    structured_prompt = f"Respond in {output_format.upper()} format only. {prompt}"
    return _call_gemini(structured_prompt, model)

import time
from google.api_core.exceptions import GoogleAPIError

def _call_gemini(prompt: str, model: str, retries: int = 3, delay: float = 2.0):
    """
    Internal helper to call Gemini with retry logic.
    Retries on network or API errors.
    """
    last_error = None

    for attempt in range(1, retries + 1):
        try:
            response = client.models.generate_content(
                model=model,
                contents=prompt,
            )

            if hasattr(response, "text") and response.text:
                return response.text.strip()

            raise ValueError("Empty response from Gemini")

        except (GoogleAPIError, ValueError, Exception) as e:
            last_error = e
            print(f"⚠️ Gemini call failed (attempt {attempt}/{retries}): {e}")
            if attempt < retries:
                time.sleep(delay * attempt)  # exponential backoff

    raise RuntimeError(f"Gemini request failed after {retries} retries: {last_error}")

from flask import Blueprint, request
from utils.ai_utils import ask_gemini

ussd_bp = Blueprint("ussd", __name__)

@ussd_bp.route("/ai-assistant", methods=["POST"])
def ai_ussd_assistant():
    session_id = request.values.get("sessionId")
    phone_number = request.values.get("phoneNumber")
    text = request.values.get("text", "")

    if text == "":
        # Welcome menu
        response = "CON AI Assistant\n"
        response += "1. Ask a question\n"
        response += "2. Get account tips\n"
        response += "3. Support"
    
    elif text == "1":
        response = "CON Type your question:"
    
    elif text.startswith("1*"):
        # Extract user's question
        question = text.split("*", 1)[1]
        
        # Get AI response
        prompt = f"You are a helpful assistant. Answer briefly (max 160 chars): {question}"
        try:
            ai_answer = ask_gemini(prompt)
            response = f"END {ai_answer}"
        except Exception as e:
            response = f"END Sorry, I couldn't process your question. Please try again."
    
    else:
        response = "END Invalid option"
    
    return response

from flask import Blueprint, request, Response
from utils.ai_utils import ask_gemini_as_xml

voice_bp = Blueprint("voice", __name__)

@voice_bp.route("/ai-support", methods=["POST"])
def ai_voice_support():
    caller = request.values.get("callerNumber")
    
    # Get personalized greeting based on time of day
    prompt = "Generate a brief, professional phone greeting for a customer calling a support line"
    
    try:
        # Returns properly formatted XML for Voice API
        xml_response = ask_gemini_as_xml(prompt)
        return Response(xml_response, mimetype="text/plain")
    except Exception as e:
        # Fallback to static response
        fallback = '<?xml version="1.0" encoding="UTF-8"?><Response><Say>Welcome to customer support. Please hold.</Say></Response>'
        return Response(fallback, mimetype="text/plain")

from flask import Blueprint, request, Response
from utils.sms_utils import send_twoway_sms
from utils.ai_utils import ask_gemini

sms_bp = Blueprint("sms", __name__)

@sms_bp.route("/ai-responder", methods=["POST"])
def ai_sms_responder():
    sender = request.values.get("from")
    message = request.values.get("text")
    
    # Generate intelligent response
    prompt = f"""
    You are a customer service SMS bot. Reply professionally and briefly (max 160 chars).
    Customer message: {message}
    """
    
    try:
        ai_response = ask_gemini(prompt)
        send_twoway_sms(message=ai_response, recipient=sender)
    except Exception as e:
        # Fallback response
        send_twoway_sms(
            message="Thank you for your message. A representative will respond shortly.",
            recipient=sender
        )
    
    return Response("OK", status=200)

from flask import Blueprint, request
from utils.ai_utils import ask_gemini_structured
from utils.airtime_utils import send_airtime
import json

airtime_bp = Blueprint("airtime", __name__)

@airtime_bp.route("/natural-language", methods=["POST"])
def nl_airtime_request():
    # User sends: "Send 100 shillings airtime to +254711000111"
    user_message = request.values.get("text")
    
    prompt = f"""
    Extract airtime transfer details from this message.
    Return JSON with: phone, amount, currency.
    Message: {user_message}
    """
    
    try:
        structured_data = ask_gemini_structured(prompt, output_format="json")
        data = json.loads(structured_data)
        
        # Validate and execute
        if "phone" in data and "amount" in data:
            result = send_airtime(
                phone=data["phone"],
                amount=float(data["amount"]),
                currency=data.get("currency", "KES")
            )
            return {"status": "success", "result": result}
        else:
            return {"error": "Could not extract phone or amount"}, 400
            
    except Exception as e:
        return {"error": f"Processing failed: {str(e)}"}, 500