import os
from tenacity import retry, stop_after_attempt, wait_exponential
import google.generativeai as genai

# Configuration for Production
genai.configure(api_key=os.environ.get("GEMINI_API_KEY"))

@retry(
    wait=wait_exponential(multiplier=1, min=4, max=10),
    stop=stop_after_attempt(5)
)
def production_call(prompt):
    """A resilient caller designed for serverless environments."""
    try:
        # Utilizing Flash for production-grade speed and cost-efficiency
        model = genai.GenerativeModel('gemini-1.5-flash')
        response = model.generate_content(prompt)
        return {
            "status": "success",
            "data": response.text,
            "usage": response.usage_metadata.total_token_count
        }
    except Exception as e:
        print(f"Deploy Alert: Transient error detected. Retrying... {e}")
        raise e

# Cloud Handler Example (AWS Lambda / GCP Cloud Functions style)
def cloud_handler(event, context):
    query = event.get("query", "Audit system health")
    return production_call(query)

1
import { GoogleGenerativeAI } from "@google/generative-ai";
2
import pRetry from 'p-retry';
3

4
const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);
5

6
const productionCall = async (prompt) => {
7
    return await pRetry(async () => {
8
        try {
9
            // Using Flash for production speed/cost
10
            const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
11
            const result = await model.generateContent(prompt);
12
            const response = await result.response;
13

14
            return {
15
                status: "success",
16
                data: response.text(),
17
                usage: response.usageMetadata.totalTokenCount
18
            };
19
        } catch (e) {
20
            console.error(`Deploy Alert: Transient error. Retrying... ${e.message}`);
21
            throw e; // p-retry catches this and triggers wait_exponential
22
        }
23
    }, {
24
        retries: 5,
25
        minTimeout: 4000,
26
        maxTimeout: 10000
27
    });
28
};
29

30
// Cloud Handler (GCP/Firebase/Vercel style)
31
export const cloudHandler = async (req, res) => {
32
    const query = req.body.query || "Audit system health";
33
    const result = await productionCall(query);
34
    res.status(200).json(result);
35
};

1
import com.github.rholder.retry.*;
2
import java.util.concurrent.TimeUnit;
3
import java.util.Map;
4
import java.util.HashMap;
5

6
public class DeployHandler {
7

8
    public Map<String, Object> productionCall(String prompt) throws Exception {
9
        Retryer<Map<String, Object>> retryer = RetryerBuilder.<Map<String, Object>>newBuilder()
10
            .retryIfException()
11
            .withWaitStrategy(WaitStrategies.exponentialWait(4, 10, TimeUnit.SECONDS))
12
            .withStopStrategy(StopStrategies.stopAfterAttempt(5))
13
            .build();
14

15
        return retryer.call(() -> {
16
            try {
17
                // Assuming model.generate returns a response object with metadata
18
                var response = model.generate(prompt);
19

20
                Map<String, Object> result = new HashMap<>();
21
                result.put("status", "success");
22
                result.put("data", response.text());
23
                result.put("usage", response.tokenCount());
24
                return result;
25
            } catch (Exception e) {
26
                System.out.println("Deploy Alert: Error. Retrying... " + e.getMessage());
27
                throw e;
28
            }
29
        });
30
    }
31

32
    // Example handler for AWS Lambda in Java
33
    public Map<String, Object> handleRequest(Map<String, String> event) throws Exception {
34
        String query = event.getOrDefault("query", "Audit system health");
35
        return productionCall(query);
36
    }
37
}