# 1️⃣ Clone the repo (optional)
git clone https://github.com/icarax/openai-agent-demo.git
cd openai-agent-demo/python

# 2️⃣ Create a virtual environment
python -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activate

# 3️⃣ Install dependencies
pip install --upgrade pip
pip install openai python-dotenv tenacity

# 1️⃣ Clone the repo (optional)
git clone https://github.com/icarax/openai-agent-demo.git
cd openai-agent-demo/js

# 2️⃣ Install Node deps
npm ci          # or `yarn install` / `pnpm install`

# 3️⃣ Install core packages
npm install openai dotenv zod   # zod for runtime validation
# If you prefer TypeScript:
npm install -D typescript @types/node ts-node
npx tsc --init   # creates a basic tsconfig.json

# file: agent.py
"""
Secure OpenAI agent demo (Python).

- Uses function calling to ask the model to retrieve data from a whitelisted URL.
- Implements exponential back‑off retries via `tenacity`.
- Loads configuration from a .env file (see Step 4).
"""

import os
import json
import logging
from typing import List, Dict, Any

import openai
from dotenv import load_dotenv
from tenacity import retry, wait_exponential, stop_after_attempt, retry_if_exception_type

# ----------------------------------------------------------------------
# Configuration & logging
# ----------------------------------------------------------------------
load_dotenv()  # reads .env into os.environ
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
if not OPENAI_API_KEY:
    raise RuntimeError("OPENAI_API_KEY not set in environment")

openai.api_key = OPENAI_API_KEY
openai.api_base = os.getenv("OPENAI_API_BASE", None)  # e.g., for Azure OpenAI

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(name)s - %(message)s",
)
log = logging.getLogger("openai_agent")

# ----------------------------------------------------------------------
# Whitelist – ONLY these hosts may be contacted by the agent
# ----------------------------------------------------------------------
ALLOWED_HOSTS = {
    "data.gov.au",
    "www.abs.gov.au",
    # add any other domains you explicitly trust
}

def _is_host_allowed(url: str) -> bool:
    """Very simple host‑allowlist check."""
    try:
        from urllib.parse import urlparse
        host = urlparse(url).hostname or ""
        return host.endswith(tuple(ALLOWED_HOSTS))
    except Exception:
        return False

# ----------------------------------------------------------------------
# Tool definition – the model can call this function to fetch a URL
# ----------------------------------------------------------------------
def fetch_allowed_url(url: str) -> str:
    """
    Retrieve the raw text content of `url` **only** if it passes the allowlist.
    In production replace this with a secured internal proxy that adds
    timeout, user‑agent, and further sanitisation.
    """
    if not _is_host_allowed(url):
        raise ValueError(f"URL not allowed: {url}")

    import requests

    try:
        resp = requests.get(url, timeout=10, headers={"User-Agent": "OpenAI-Agent/1.0"})
        resp.raise_for_status()
        # Truncate to avoid overwhelming the model with huge payloads
        content = resp.text[:8000]
        log.info(f"Fetched {len(content)} chars from {url}")
        return content
    except requests.RequestException as exc:
        log.error(f"HTTP error while fetching {url}: {exc}")
        raise

# ----------------------------------------------------------------------
# OpenAI function schema (as defined by the Chat Completions API)
# ----------------------------------------------------------------------
FETCH_URL_FUNCTION = {
    "name": "fetch_allowed_url",
    "description": "Fetch the contents of a whitelisted URL. Use only for trusted government or public data sources.",
    "parameters": {
        "type": "object",
        "properties": {
            "url": {
                "type": "string",
                "description": "The URL to fetch (must be on the allowlist).",
            }
        },
        "required": ["url"],
        "additionalProperties": False,
    },
}

# ----------------------------------------------------------------------
# Core agent logic – retry on transient errors (rate limits, network glitches)
# ----------------------------------------------------------------------
@retry(
    reraise=True,
    stop=stop_after_attempt(4),
    wait=wait_exponential(multiplier=1, min=2, max=20),
    retry=retry_if_exception_type((openai.error.RateLimitError, openai.error.APIConnectionError)),
)
def run_agent(user_query: str) -> str:
    """
    Send a query to the model, allowing it to call `fetch_allowed_url` if needed.
    Returns the final assistant message.
    """
    messages: List[Dict[str, Any]] = [
        {"role": "system", "content": (
            "You are a helpful research assistant. "
            "When you need up‑to‑date factual data, you MUST call the `fetch_allowed_url` function "
            "with a URL from the allowed list. Never fabricate URLs or claim to have visited a site "
            "without using the tool."
        )},
        {"role": "user", "content": user_query},
    ]

    response = openai.ChatCompletion.create(
        model=os.getenv("OPENAI_MODEL", "gpt-4-turbo-preview"),
        messages=messages,
        tools=[{"type": "function", "function": FETCH_URL_FUNCTION}],
        tool_choice="auto",  # let the model decide when to use the tool
        temperature=0.2,
        max_tokens=1500,
    )

    # ------------------------------------------------------------------
    # Handle possible tool calls
    # ------------------------------------------------------------------
    if response.choices[0].message.get("tool_calls"):
        tool_calls = response.choices[0].message["tool_calls"]
        # Append the assistant's message with tool_calls so the model sees it
        messages.append(response.choices[0].message)

        for tool_call in tool_calls:
            if tool_call["function"]["name"] == "fetch_allowed_url":
                args = json.loads(tool_call["function"]["arguments"])
                url = args["url"]
                try:
                    result = fetch_allowed_url(url)
                except Exception as exc:
                    # Return a friendly error to the model so it can adjust
                    result = f"Error fetching URL: {exc}"
                # Append the tool result
                messages.append(
                    {
                        "role": "tool",
                        "tool_call_id": tool_call["id"],
                        "name": "fetch_allowed_url",
                        "content": result,
                    }
                )
        # Get a final response after the tool output
        final_response = openai.ChatCompletion.create(
            model=os.getenv("OPENAI_MODEL", "gpt-4-turbo-preview"),
            messages=messages,
            temperature=0.2,
            max_tokens=1500,
        )
        return final_response.choices[0].message["content"]
    else:
        # No tool used – just return the model's answer
        return response.choices[0].message["content"]

# ----------------------------------------------------------------------
# Simple CLI entrypoint
# ----------------------------------------------------------------------
if __name__ == "__main__":
    import sys
    if len(sys.argv) < 2:
        print("Usage: python agent.py \"<your question>\"")
        sys.exit(1)

    question = " ".join(sys.argv[1:])
    try:
        answer = run_agent(question)
        print("\n=== Assistant Answer ===\n")
        print(answer)
    except Exception as e:
        log.exception("Agent failed")
        print(f"\n❌ Error: {e}")

// file: agent.ts
/*
Secure OpenAI agent demo (TypeScript).

- Uses the OpenAI Chat Completions API with function calling.
- Validates URLs against an allowlist before performing an HTTP request.
- Implements retry with exponential back‑off via a tiny helper.
- Requires Node >=18 and `dotenv` for config.
*/

import { Configuration, OpenAIApi } from "openai";
import * as dotenv from "dotenv";
import * as z from "zod";
import axios from "axios";
import { log } from "console";

// ----------------------------------------------------------------------
// Load environment variables
// ----------------------------------------------------------------------
dotenv.config();
const OPENAI_API_KEY = process.env.OPENAI_API_KEY;
if (!OPENAI_API_KEY) {
  throw new Error("Missing OPENAI_API_KEY in environment");
}
const OPENAI_MODEL = process.env.OPENAI_MODEL ?? "gpt-4-turbo-preview";

const configuration = new Configuration({
  apiKey: OPENAI_API_KEY,
  // basePath: process.env.OPENAI_API_BASE, // Uncomment for Azure/OpenAI proxies
});
const openai = new OpenAIApi(configuration);

// ----------------------------------------------------------------------
// Allowlist – only these hosts may be fetched
// ----------------------------------------------------------------------
const ALLOWED_HOSTS = new Set([
  "data.gov.au",
  "www.abs.gov.au",
  // add more as needed
]);

function isHostAllowed(url: string): boolean {
  try {
    const { hostname } = new URL(url);
    return hostname && [...ALLOWED_HOSTS].some((h) => hostname.endsWith(h));
  } catch {
    return false;
  }
}

// ----------------------------------------------------------------------
// Tool: fetch a whitelisted URL (returns plain text, truncated)
// ----------------------------------------------------------------------
const fetchUrlSchema = z.object({
  url: z.string().url().refine(isHostAllowed, {
    message: "URL is not on the allowlist",
  }),
});

type FetchUrlArgs = z.infer<typeof fetchUrlSchema>;

async function fetchAllowedUrl(args: FetchUrlArgs): Promise<string> {
  const { url } = args;
  try {
    const resp = await axios.get(url, {
      timeout: 10_000,
      headers: { "User-Agent": "OpenAI-Agent/1.0" },
    });
    // Truncate to avoid token overflow
    const content = resp.data.slice(0, 8000);
    console.log(`Fetched ${content.length} chars from ${url}`);
    return content;
  } catch (err: any) {
    console.error(`HTTP error fetching ${url}:`, err.message);
    throw new Error(`Failed to fetch ${url}: ${err.message}`);
  }
}

// ----------------------------------------------------------------------
// OpenAI function definition
// ----------------------------------------------------------------------
const fetchUrlFunction = {
  name: "fetch_allowed_url",
  description:
    "Fetch the contents of a whitelisted URL. Use only for trusted government or public data sources.",
  parameters: fetchUrlSchema.shape,
};

// ----------------------------------------------------------------------
// Retry helper (exponential back‑off)
// ----------------------------------------------------------------------
async function retryable<T>(
  fn: () => Promise<T>,
  retries = 4,
  minDelay = 2000,
  maxDelay = 20000
): Promise<T> {
  let attempt = 0;
  while (true) {
    try {
      return await fn();
    } catch (err: any) {
      attempt++;
      if (attempt > retries) throw err;
      // Only retry on rate limit or network errors
      const isRetryable =
        err.code === "rate_limit_exceeded" ||
        err.code === "ECONNABORTED" ||
        err.code === "ETIMEDOUT";
      if (!isRetryable) throw err;
      const delay = Math.min(maxDelay, minDelay * 2 ** attempt) + Math.random() * 1000;
      console.log(`Retry ${attempt}/${retries} after ${Math.round(delay)}ms…`);
      await new Promise((res) => setTimeout(res, delay));
    }
  }
}

// ----------------------------------------------------------------------
// Core agent logic
// ----------------------------------------------------------------------
interface ChatMessage {
  role: "system" | "user" | "assistant" | "tool";
  content: string;
  name?: string;
  tool_call_id?: string;
}

async function runAgent(userQuery: string): Promise<string> {
  const messages: ChatMessage[] = [
    {
      role: "system",
      content:
        "You are a helpful research assistant. When you need up‑to‑date factual data, you MUST call the `fetch_allowed_url` function with a URL from the allowed list. Never fabricate URLs or claim to have visited a site without using the tool.",
    },
    { role: "user", content: userQuery },
  ];

  // First call – let the model decide whether to use the tool
  const firstResponse = await retryable(() =>
    openai.createChatCompletion({
      model: OPENAI_MODEL,
      messages,
      tools: [{ type: "function", function: fetchUrlFunction }],
      tool_choice: "auto",
      temperature: 0.2,
      max_tokens: 1500,
    })
  );

  const firstMsg = firstResponse.data.choices[0].message;
  messages.push(firstMsg as ChatMessage); // preserve assistant message with possible tool_calls

  if (firstMsg.tool_calls?.length) {
    // Execute each tool call sequentially (you could parallelise if safe)
    for (const toolCall of firstMsg.tool_calls) {
      if (toolCall.function.name === "fetch_allowed_url") {
        const args = JSON.parse(toolCall.function.arguments) as FetchUrlArgs;
        let toolResult: string;
        try {
          toolResult = await fetchAllowedUrl(args);
        } catch (err: any) {
          toolResult = `Error fetching URL: ${err.message}`;
        }
        messages.push({
          role: "tool",
          tool_call_id: toolCall.id,
          name: "fetch_allowed_url",
          content: toolResult,
        });
      }
    }

    // Second call – give the model the tool output to craft the final answer
    const secondResponse = await retryable(() =>
      openai.createChatCompletion({
        model: OPENAI_MODEL,
        messages,
        temperature: 0.2,
        max_tokens: 1500,
      })
    );
    return secondResponse.data.choices[0].message.content ?? "";
  }

  // No tool used
  return firstMsg.content ?? "";
}

// ----------------------------------------------------------------------
// Simple CLI
// ----------------------------------------------------------------------
async function main() {
  const [, , ...args] = process.argv;
  if (args.length === 0) {
    console.error('Usage: npx ts-node agent.ts "Your question here"');
    process.exit(1);
  }
  const question = args.join(" ");
  try {
    const answer = await runAgent(question);
    console.log("\n=== Assistant Answer ===\n");
    console.log(answer);
  } catch (err: any) {
    console.error("\n❌ Agent failed:", err.message);
    process.exit(1);
  }
}

main();

# .env – keep this file out of VCS (add to .gitignore)
OPENAI_API_KEY=sk-XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
OPENAI_MODEL=gpt-4-turbo-preview   # optional – defaults to gpt-4-turbo-preview
# OPENAI_API_BASE=https://your-azure-openai-instance.openai.azure.com/  # Uncomment for Azure

import { z } from "zod";

const QuerySchema = z.object({
  question: z.string().min(1).max(500),
});

type Query = z.infer<typeof QuerySchema>;

function validateQuery(raw: string): Query {
  return QuerySchema.parse({ question: raw });
}

import tiktoken

enc = tiktoken.encoding_for_model("gpt-4-turbo-preview")
def count_tokens(text: str) -> int:
    return len(enc.encode(text))

stream = openai.ChatCompletion.create(
    model="gpt-4-turbo-preview",
    messages=[{"role":"user","content":"Tell me a story about a kangaroo"}],
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta.get("content", "")
    if delta:
        print(delta, end="", flush=True)
print()

async function safeCall<T>(
  fn: () => Promise<T>,
  fallback: T,
  context: string
): Promise<T> {
  try {
    return await fn();
  } catch (e) {
    console.error(`[${context}] Error:`, e);
    return fallback;
  }
}

app.use(async (req, res, next) => {
  const res = await openai.createChatCompletion({ /* … */ });
  const remaining = Number(res.headers["x-ratelimit-remaining-requests"]);
  if (remaining < 5) {
    const reset = Number(res.headers["x-ratelimit-reset-requests"]);
    const waitMs = Math.max(0, reset * 1000 - Date.now()) + 1000;
    await new Promise(r => setTimeout(r, waitMs));
  }
  next();
});

import openai, logging
logging.basicConfig(level=logging.DEBUG)
openai.debug = True

// In TS, set environment variable before running:
export OPENAI_DEBUG=true
node -r ts-node/register agent.ts