# 1️⃣ Create a clean virtual environment
python3 -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activate

# 2️⃣ Install core packages
pip install --upgrade pip
pip install openai==1.37.0   # latest stable as of Nov‑2025
pip install python-dotenv   # for .env loading
pip install prometheus_client   # optional metrics export
pip install pydantic   # data validation (optional but recommended)

# 1️⃣ Initialise a new npm project (skip if you already have one)
mkdir openai-guard && cd openai-guard
npm init -y

# 2️⃣ Install dependencies
npm i openai@4.58.0          # official OpenAI Node SDK
npm i dotenv                 # load .env files
npm i zod                    # runtime schema validation (TS-friendly)
npm i prom-client            # Prometheus metrics (optional)
npm i -D typescript ts-node @types/node @types/express   # dev tools if using TS

# 3️⃣ Create a tsconfig.json (if using TypeScript)
npx tsc --init --rootDir src --outDir dist \
  --esModuleInterop --resolveJsonModule --lib es2022,dom \
  --strict

"""
openai_guard.py
A defensive wrapper for the OpenAI Python SDK.

Features:
- API key loaded from environment (OPENAI_API_KEY)
- Per‑minute request rate limiting (token bucket)
- Structured logging (JSON‑friendly)
- Prometheus metrics (optional)
- Clear, typed exceptions
"""

import os
import time
import uuid
import logging
from threading import Lock
from dataclasses import dataclass, asdict
from typing import Any, Dict

import openai
from dotenv import load_dotenv
from prometheus_client import Counter, Histogram, start_http_server

# ----------------------------------------------------------------------
# 1️⃣ Load environment & configure logging
# ----------------------------------------------------------------------
load_dotenv()  # reads .env in CWD (do NOT commit this file!)
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
if not OPENAI_API_KEY:
    raise RuntimeError("OPENAI_API_KEY environment variable is missing")

# JSON‑lite logger – easy to ship to ELK, Splunk, etc.
logger = logging.getLogger("openai_guard")
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
formatter = logging.Formatter('%(message)s')  # we’ll output raw JSON strings
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.propagate = False

# ----------------------------------------------------------------------
# 2️⃣ Prometheus metrics (optional – disable by setting METRICS_PORT=0)
# ----------------------------------------------------------------------
METRICS_PORT = int(os.getenv("METRICS_PORT", "8000"))
if METRICS_PORT > 0:
    start_http_server(METRICS_PORT)
    REQUEST_COUNT = Counter(
        "openai_requests_total",
        "Total OpenAI API calls made",
        ["model", "result"],  # result = success|error|rate_limit
    )
    LATENCY_HIST = Histogram(
        "openai_latency_seconds",
        "Latency of OpenAI API calls",
        ["model"],
        buckets=(0.1, 0.5, 1, 2, 5, 10),
    )
else:
    REQUEST_COUNT = LATENCY_HIST = None  # type: ignore

# ----------------------------------------------------------------------
# 3️⃣ Simple token‑bucket rate limiter (per‑minute)
# ----------------------------------------------------------------------
@dataclass
class TokenBucket:
    capacity: int          # max tokens (requests) allowed in the window
    fill_rate: float       # tokens added per second
    _tokens: float = None
    _timestamp: float = None
    _lock: Lock = None

    def __post_init__(self):
        self._tokens = float(self.capacity)
        self._timestamp = time.monotonic()
        self._lock = Lock()

    def consume(self, tokens: int = 1) -> bool:
        """Try to consume `tokens`. Returns True if successful, False if not enough."""
        with self._lock:
            now = time.monotonic()
            # Add tokens based on elapsed time
            elapsed = now - self._timestamp
            self._tokens = min(self.capacity, self._tokens + elapsed * self.fill_rate)
            self._timestamp = now

            if self._tokens >= tokens:
                self._tokens -= tokens
                return True
            return False

# Example: 60 requests per minute => 1 request per second
RATE_LIMITER = TokenBucket(capacity=60, fill_rate=1.0)

# ----------------------------------------------------------------------
# 4️⃣ Wrapper class
# ----------------------------------------------------------------------
class OpenAIGuard:
    """
    Usage:
        guard = OpenAIGuard()
        resp = guard.chat_completion(
            model="gpt-4-turbo",
            messages=[{"role":"user","content":"Hello!"}],
            temperature=0.2,
        )
    """

    def __init__(self, api_key: str | None = None):
        self.api_key = api_key or OPENAI_API_KEY
        openai.api_key = self.api_key

    # ------------------------------------------------------------------
    # Internal helpers
    # ------------------------------------------------------------------
    def _log_event(self, event: Dict[str, Any]) -> None:
        """Emit a single line JSON log."""
        logger.info(event)

    def _record_metrics(self, model: str, success: bool, latency: float) -> None:
        if not REQUEST_COUNT:
            return
        result = "success" if success else "error"
        REQUEST_COUNT.labels(model=model, result=result).inc()
        LATENCY_HIST.labels(model=model).observe(latency)

    # ------------------------------------------------------------------
    # Public API – chat completion example (extend for embeddings, etc.)
    # ------------------------------------------------------------------
    def chat_completion(
        self,
        *,
        model: str,
        messages: list[dict],
        temperature: float = 0.7,
        max_tokens: int | None = None,
        **kwargs: Any,
    ) -> dict:
        """
        Calls `openai.ChatCompletion.create` with safety wrappers.

        Returns the raw response dict from the SDK.
        Raises:
            RateLimitError – when the local token bucket is empty.
            OpenAIError – propagated from the SDK (network, auth, etc.).
        """
        # 1️⃣ Rate‑limit check
        if not RATE_LIMITER.consume():
            raise RateLimitError("Per‑minute request quota exceeded")

        # 2️⃣ Prepare logging context
        request_id = str(uuid.uuid4())
        start = time.monotonic()
        log_base = {
            "request_id": request_id,
            "model": model,
            "temperature": temperature,
            "max_tokens": max_tokens,
            "message_count": len(messages),
        }

        try:
            # 3️⃣ Actual SDK call (timeout can be added via `request_timeout`)
            response = openai.ChatCompletion.create(
                model=model,
                messages=messages,
                temperature=temperature,
                max_tokens=max_tokens,
                request_timeout=20,  # seconds – adjust to your SLA
                **kwargs,
            )
            latency = time.monotonic() - start
            success = True
            # 4️⃣ Emit success log & metrics
            self._log_event({**log_base, "event": "response", "latency_sec": latency})
            self._record_metrics(model, success, latency)
            return response

        except openai.error.RateLimitError as e:
            # Upstream rate limit (different from our local guard)
            latency = time.monotonic() - start
            self._log_event({**log_base, "event": "upstream_rate_limit", "error": str(e), "latency_sec": latency})
            self._record_metrics(model, False, latency)
            raise  # re‑raise – caller may want to back‑off

        except openai.error.OpenAIError as e:
            latency = time.monotonic() - start
            self._log_event({**log_base, "event": "error", "error": str(e), "latency_sec": latency})
            self._record_metrics(model, False, latency)
            raise

        except Exception as e:  # catch‑all for unexpected issues
            latency = time.monotonic() - start
            self._log_event({**log_base, "event": "unexpected_error", "error": str(e), "latency_sec": latency})
            self._record_metrics(model, False, latency)
            raise


# ----------------------------------------------------------------------
# 5️⃣ Custom exception types (helps callers differentiate)
# ----------------------------------------------------------------------
class RateLimitError(RuntimeError):
    """Raised when the local per‑minute quota is exhausted."""
    pass


# ----------------------------------------------------------------------
# 6️⃣ Quick sanity‑check when run as script
# ----------------------------------------------------------------------
if __name__ == "__main__":
    guard = OpenAIGuard()
    try:
        resp = guard.chat_completion(
            model="gpt-4-turbo",
            messages=[{"role": "user", "content": "Say hello in one word."}],
            max_tokens=5,
        )
        print("✅ Response:", resp["choices"][0]["message"]["content"])
    except RateLimitError as rl:
        print("⚠️ Local rate limit hit:", rl)
    except Exception as exc:
        print("❌ OpenAI error:", exc)

# 1️⃣ Create a .env file (never commit this!)
echo "OPENAI_API_KEY=sk‑your‑real‑key-here" > .env
echo "METRICS_PORT=8000" >> .env   # optional; set to 0 to disable

# 2️⃣ Execute
python openai_guard.py

/**
 * openaiGuard.ts
 * Defensive wrapper for the OpenAI Node.js SDK.
 *
 * Features:
 * - API key from process.env.OPENAI_API_KEY
 * - Per‑minute token‑bucket rate limiter
 * - Structured JSON logging (console)
 * - Optional Prometheus metrics (prom-client)
 * - Typed error classes
 */

import { Configuration, OpenAIApi, ChatCompletion } from "openai";
import dotenv from "dotenv";
import { v4 as uuidv4 } from "uuid";
import { Counter, Histogram, collectDefaultMetrics, Registry } from "prom-client";

// Load .env (do NOT commit this file!)
dotenv.config();

const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
if (!OPENAI_API_KEY) {
  throw new Error("Missing OPENAI_API_KEY environment variable");
}

// ---------------------------------------------------------------------
// Prometheus setup (optional)
// -----------------------------------------------------------------
const METRICS_PORT = Number(process.env.METRICS_PORT || "0");
let requestCounter: Counter<string> | null = null;
let latencyHist: Histogram<string> | null = null;

if (METRICS_PORT > 0) {
  const register = new Registry();
  collectDefaultMetrics({ register });

  requestCounter = new Counter({
    name: "openai_requests_total",
    help: "Total OpenAI API calls made",
    labelNames: ["model", "result"],
    registers: [register],
  });

  latencyHist = new Histogram({
    name: "openai_latency_seconds",
    help: "Latency of OpenAI API calls",
    labelNames: ["model"],
    buckets: [0.1, 0.5, 1, 2, 5, 10],
    registers: [register],
  });

  // Start HTTP endpoint
  import("prom-client").then(({ startHttpServer }) => {
    startHttpServer(METRICS_PORT, { register });
    console.log(`📈 Prometheus metrics exposed on :${METRICS_PORT}/metrics`);
  });
}

// ---------------------------------------------------------------------
// Simple token‑bucket (per‑minute)
// -----------------------------------------------------------------
class TokenBucket {
  private tokens: number;
  private last: number;
  private readonly capacity: number;
  private readonly fillPerSec: number;
  private readonly lock: Promise<void>;

  constructor(capacity: number, fillPerSec: number) {
    this.capacity = capacity;
    this.fillPerSec = fillPerSec;
    this.tokens = capacity; // start full
    this.last = Date.now() / 1000;
    this.lock = Promise.resolve();
  }

  async consume(tokensRequested = 1): Promise<boolean> {
    await this.lock;
    const now = Date.now() / 1000;
    const elapsed = now - this.last;
    this.tokens = Math.min(this.capacity, this.tokens + elapsed * this.fillPerSec);
    this.last = now;

    if (this.tokens >= tokensRequested) {
      this.tokens -= tokensRequested;
      this.lock = Promise.resolve(); // release
      return true;
    }
    this.lock = Promise.resolve(); // still release – caller will retry later
    return false;
  }
}

// 60 requests/minute = 1 req/sec
const rateLimiter = new TokenBucket(60, 1);

// ---------------------------------------------------------------------
// Logger – emits a single JSON line per event
// -----------------------------------------------------------------
function logEvent(obj: Record<string, unknown>): void {
  console.log(JSON.stringify(obj));
}

// ---------------------------------------------------------------------
// Custom error types
// -----------------------------------------------------------------
export class RateLimitError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "RateLimitError";
  }
}

// ---------------------------------------------------------------------
// Main wrapper class
// -----------------------------------------------------------------
export class OpenAIGuard {
  private readonly openai: OpenAIApi;

  constructor(apiKey: string = OPENAI_API_KEY) {
    const config = new Configuration({ apiKey });
    this.openai = new OpenAIApi(config);
  }

  /**
   * Creates a chat completion with safety wrappers.
   * Throws RateLimitError if local quota exhausted.
   * Propagates OpenAI errors (network, auth, etc.).
   */
  async chatCompletion(params: {
    model: string;
    messages: { role: string; content: string }[];
    temperature?: number;
    maxTokens?: number;
    [key: string]: any; // allow passthrough
  }): Promise<ChatCompletion> {
    // ---- 1️⃣ Local rate limit ----
    const allowed = await rateLimiter.consume();
    if (!allowed) {
      throw new RateLimitError("Per‑minute request quota exceeded");
    }

    const requestId = uuidv4();
    const start = Date.now();
    const baseLog = {
      requestId,
      model: params.model,
      temperature: params.temperature ?? 0.7,
      maxTokens: params.maxTokens,
      messageCount: params.messages.length,
    };

    try {
      const response = await this.openai.createChatCompletion({
        model: params.model,
        messages: params.messages as any,
        temperature: params.temperature,
        max_tokens: params.maxTokens,
        // timeout in ms (OpenAI SDK uses `timeout` option)
        timeout: 20_000,
        ...params, // spread any extra args (e.g., top_p, presence_penalty)
      });

      const latency = (Date.now() - start) / 1000;
      const success = true;

      // ---- 2️⃣ Logging & metrics ----
      logEvent({ ...baseLog, event: "response", latencySec: latency });
      if (requestCounter && latencyHist) {
        requestCounter.inc({ model: params.model, result: "success" });
        latencyHist.observe({ model: params.model }, latency);
      }

      return response.data;
    } catch (err: any) {
      const latency = (Date.now() - start) / 1000;
      const isOpenAIError = err?.response?.status !== undefined;
      logEvent({
        ...baseLog,
        event: isOpenAIError ? "error" : "unexpected_error",
        error: err?.message ?? String(err),
        status: err?.response?.status,
        latencySec: latency,
      });

      if (requestCounter && latencyHist) {
        requestCounter.inc({ model: params.model, result: "error" });
        latencyHist.observe({ model: params.model }, latency);
      }

      // Re‑throw so caller can decide what to do
      throw err;
    }
  }
}

// ---------------------------------------------------------------------
// Example usage when run directly (ts-node src/openaiGuard.ts)
// ---------------------------------------------------------------------
if (require.main === module) {
  (async () => {
    const guard = new OpenAIGuard();
    try {
      const resp = await guard.chatCompletion({
        model: "gpt-4-turbo",
        messages: [{ role: "user", content: "Give me a one‑word greeting." }],
        maxTokens: 5,
      });
      console.log("✅ Reply:", resp.choices[0]?.message?.content?.trim());
    } catch (e) {
      if (e instanceof RateLimitError) {
        console.warn("⚠️ Local rate limit:", e.message);
      } else {
        console.error("❌ OpenAI error:", e);
      }
    }
  })();
}

# 1️⃣ Create .env (same as Python)
echo "OPENAI_API_KEY=sk‑your‑real‑key-here" > .env
echo "METRICS_PORT=8000" >> .env   # optional

# 2️⃣ Install dev dependencies if you haven't already
npm i -D ts-node @types/node @types/openai

# 3️⃣ Execute
npx ts-node src/openaiGuard.ts

import { z } from "zod";

const envSchema = z.object({
  OPENAI_API_KEY: z.string().min(1),
  METRICS_PORT: z.string().default("0").transform(Number),
  RATE_LIMIT_RPM: z.string().default("60").transform(Number),
});

const env = envSchema.parse(process.env);
export const OPENAI_API_KEY = env.OPENAI_API_KEY;
export const METRICS_PORT = env.METRICS_PORT;
export const RATE_LIMIT_RPM = env.RATE_LIMIT_RPM;

# Python – using structlog for richer fields
import structlog
structlog.configure(
    processors=[
        structlog.processors.TimeStamper(fmt="iso"),
        structlog.processors.JSONRenderer(),
    ],
    wrapper_class=structlog.make_filtering_bound_logger(logging.INFO),
)
logger = structlog.get_logger("openai")

// TypeScript – using pino for high‑performance JSON logging
import pino from "pino";
const logger = pino({ level: process.env.LOG_LEVEL || "info" });
logger.info({ event: "openai_request", requestId, model });

import backoff
import openai

@backoff.on_exception(
    backoff.expo,
    (openai.error.RateLimitError, openai.error.APIConnectionError),
    max_tries=5,
    jitter=None,
)
def safe_completion(**kwargs):
    return openai.ChatCompletion.create(**kwargs)

// TS – using a simple retry helper
async function retry<T>(fn: () => Promise<T>, retries = 5): Promise<T> {
  let attempt = 0;
  while (true) {
    try {
      return await fn();
    } catch (err: any) {
      if (!['RateLimitError', 'APIConnectionError', 'Timeout'].includes(err.type ?? '') || attempt >= retries) throw err;
      await new Promise(r => setTimeout(r, Math.pow(2, attempt) * 100 + Math.random() * 100));
      attempt++;
    }
  }
}

import redis
r = redis.Redis(host="localhost", port=6379, db=0)

def allow_request(customer_id: str, limit: int = 1000) -> bool:
    key = f"openai:usage:{customer_id}:{datetime.utcnow().strftime('%Y-%m-%d')}"
    current = r.incr(key)
    if current == 1:
        r.expire(key, 86400)  # reset at midnight UTC
    return current <= limit

if os.getenv("OPENAI_ENABLE_TOOLS", "false").lower() != "true":
    raise PermissionError("Tool usage is disabled in safe mode")

# prometheus.yml snippet
groups:
- name: openai.rules
  rules:
  - alert: OpenAIBurst
    expr: rate(openai_requests_total[5m]) > 120   # > 2x expected RPM
    for: 2m
    labels:
      severity: critical
    annotations:
      summary: "OpenAI request rate spike"
      description: "More than {{ $value }} req/s in the last 5 min."