Tutorial: Call center modernization with multi-agent systems

{
  "1001": {
    "name": "Alice Johnson",
    "dob": "1990-05-04",
    "soc": "123-45-6789",
    "address": "123 coffee St, Springfield, IL 12345",
    "email": "byyoung3@gmail.com",
    "balance": 2500,
    "history": [
      ["Deposit", 1000, "2024-11-15T10:30:00", "Payroll Deposit", "posted"],
      ["Withdraw", 200, "2024-12-01T13:15:00", "ATM Withdrawal", "posted"],
      ["Deposit", 1700, "2025-01-25T09:00:00", "Freelance Payment", "posted"],
      ["Withdraw", 45, "2025-02-10T11:23:00", "STARBUCKS", "posted"],
      ["Withdraw", 75, "2025-03-08T08:17:00", "UBER", "posted"],
      ["Withdraw", 120, "2025-04-12T15:45:00", "AMAZON", "posted"],
      ["Withdraw", 130, "2025-04-12T15:43:00", "AMAZON", "posted"],
      ["Withdraw", 330, "2025-04-12T15:46:00", "AMAZON", "posted"],
      ["Deposit", 300, "2025-05-10T09:00:00", "Refund", "posted"],
      ["Withdraw", 300, "2025-06-15T12:33:00", "Unknown Merchant XYZ", "posted"],
      ["Deposit", 600, "2025-07-20T16:00:00", "Bonus Deposit", "posted"],
      ["Withdraw", 95, "2025-08-05T10:20:00", "Grocery Market", "posted"],
      ["Withdraw", 180, "2025-09-29T19:40:00", "AIRLINE ABC", "failed"],
      ["Withdraw", 52, "2025-10-03T09:10:00", "LOCAL BAKERY", "failed"]
    ],
    "card": {
      "status": "active",
      "limit": 1500,
      "merchants": {
        "enabled": ["LOCAL BAKERY"],
        "disabled": ["RANDOMSHOP", "STARBUCKS", "AMAZON", "UBER"]
      },
      "travel_limits": [
        {
          "country": "FR",
          "start": "2025-12-01",
          "end": "2025-12-20",
          "daily_cap": 300
        },
        {
          "country": "JP",
          "start": "2026-01-05",
          "end": "2026-01-25",
          "daily_cap": 400
        }
      ]
    }
  },
  "2002": {
    "name": "Bob Smith",
    "dob": "1985-11-21",
    "soc": "987-65-4321",
    "address": "42 Oak Ave",
    "email": "bob.smith@example.com",
    "balance": 980,
    "history": [
      ["Deposit", 500, "2024-09-20T09:10:00", "Payroll Deposit", "posted"],
      ["Deposit", 480, "2024-11-02T09:00:00", "Gift Transfer", "posted"],
      ["Withdraw", 200, "2025-01-10T12:00:00", "NETFLIX", "posted"],
      ["Deposit", 300, "2025-02-18T10:00:00", "Freelance Payment", "posted"],
      ["Withdraw", 100, "2025-03-12T18:30:00", "SPOTIFY", "posted"],
      ["Withdraw", 65, "2025-04-14T14:50:00", "CASINO ONLINE", "failed"],
      ["Deposit", 450, "2025-06-10T09:10:00", "Tax Refund", "posted"],
      ["Withdraw", 125, "2025-07-20T10:20:00", "FASTFOOD PLACE", "posted"],
      ["Withdraw", 300, "2025-08-25T13:45:00", "Unknown Charge QRS", "posted"],
      ["Withdraw", 90, "2025-10-01T21:05:00", "BETTING APP", "failed"]
    ],
    "card": {
      "status": "frozen",
      "limit": 800,
      "merchants": {
        "enabled": ["SPOTIFY", "NETFLIX"],
        "disabled": ["CASINO", "BETTING"]
      },
      "travel_limits": []
    }
  },
  "3003": {
    "name": "Carla Mendes",
    "dob": "1992-08-10",
    "soc": "222-33-4444",
    "address": "98 Pine Blvd",
    "email": "carla.mendes@example.com",
    "balance": 6500,
    "history": [
      ["Deposit", 4000, "2024-10-01T08:45:00", "Payroll Deposit", "posted"],
      ["Withdraw", 500, "2024-11-22T16:30:00", "WHOLEFOODS", "posted"],
      ["Deposit", 3000, "2025-01-15T08:00:00", "Bonus Payment", "posted"],
      ["Withdraw", 2000, "2025-02-08T13:20:00", "DELTA Airlines", "posted"],
      ["Deposit", 1000, "2025-03-10T08:15:00", "Tax Refund", "posted"],
      ["Withdraw", 850, "2025-04-05T10:40:00", "AIRBNB", "posted"],
      ["Withdraw", 400, "2025-05-22T12:05:00", "Online Boutique", "posted"],
      ["Withdraw", 250, "2025-07-17T15:00:00", "Unknown Vendor JKL", "posted"],
      ["Withdraw", 120, "2025-10-04T11:00:00", "LOCAL MUSEUM", "failed"]
    ],
    "card": {
      "status": "active",
      "limit": 5000,
      "merchants": {
        "enabled": ["AIRBNB", "DELTA", "WHOLEFOODS"],
        "disabled": []
      },
      "travel_limits": [
        {
          "country": "ES",
          "start": "2025-10-01",
          "end": "2025-10-15",
          "daily_cap": 800
        }
      ]
    }
  },
  "4004": {
    "name": "Daniel Green",
    "dob": "1978-02-14",
    "soc": "111-22-3333",
    "address": "77 Birch Rd, St. Louis, MO 12345",
    "email": "daniel.green@example.com",
    "balance": 12000,
    "history": [
      ["Deposit", 6000, "2024-12-05T09:00:00", "Salary Deposit", "posted"],
      ["Withdraw", 1000, "2025-01-10T10:00:00", "HOMEDEPOT", "posted"],
      ["Deposit", 7000, "2025-03-01T09:30:00", "Investment Return", "posted"],
      ["Withdraw", 2000, "2025-04-12T14:00:00", "APPLE", "posted"],
      ["Deposit", 2000, "2025-05-15T09:30:00", "Bonus", "posted"],
      ["Withdraw", 250, "2025-07-18T16:30:00", "COSTCO", "posted"],
      ["Withdraw", 900, "2025-08-25T18:20:00", "BETTINGSHOP", "failed"],
      ["Withdraw", 400, "2025-09-10T11:45:00", "Unknown Charge ABC", "posted"],
      ["Withdraw", 1800, "2025-10-02T12:10:00", "HOLIDAY INN", "failed"]
    ],
    "card": {
      "status": "active",
      "limit": 10000,
      "merchants": {
        "enabled": ["HOMEDEPOT", "APPLE", "COSTCO"],
        "disabled": ["BETTINGSHOP"]
      },
      "travel_limits": [
        {
          "country": "GB",
          "start": "2025-11-01",
          "end": "2025-11-15",
          "daily_cap": 500
        },
        {
          "country": "IT",
          "start": "2026-02-01",
          "end": "2026-02-20",
          "daily_cap": 600
        }
      ]
    }
  }
}

import os
import json
from pathlib import Path
from typing import Any, Dict, List, Tuple, Optional
from openai import OpenAI

class BankSystem:
    def __init__(self, db_file: str = "bank_data.json"):
        self.db_path = Path(db_file)
        self.client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
        if not self.db_path.exists():
            self.db_path.write_text("{}", encoding="utf-8")

    def _load_db(self) -> Dict[str, Any]:
        return json.loads(self.db_path.read_text(encoding="utf-8"))

    def _save_db(self, data: Dict[str, Any]) -> None:
        self.db_path.write_text(json.dumps(data, indent=2), encoding="utf-8")

    def _get_account(self, account_number: str) -> Tuple[Dict[str, Any], Dict[str, Any]]:
        data = self._load_db()
        if account_number not in data:
            raise KeyError("Account not found")
        return data, data[account_number]

    def _ensure_card_fields(self, acc: Dict[str, Any]) -> None:
        if "card" not in acc:
            acc["card"] = {
                "status": "active",
                "limit": 0,
                "merchants": {"enabled": [], "disabled": []},
                "travel_limits": []
            }

    def _ensure_email_field(self, acc: Dict[str, Any]) -> None:
        if "email" not in acc:
            acc["email"] = None

    def _normalize_history(self, acc: Dict[str, Any]) -> None:
        # History entries are [type, amount, timestamp, description] or [type, amount, timestamp, description, status]
        hist = acc.get("history") or []
        norm = []
        for entry in hist:
            if len(entry) == 4:
                ttype, amt, ts, desc = entry
                status = "posted"
            elif len(entry) >= 5:
                ttype, amt, ts, desc, status = entry[:5]
            else:
                # Skip malformed rows
                continue
            norm.append([ttype, amt, ts, desc, status])
        acc["history"] = norm

    def register_customer(
        self,
        name: str,
        dob: str,
        soc: str,
        address: str,
        account_number: str,
        balance: float = 0.0,
        card_limit: float = 0.0,
        email: Optional[str] = None
    ) -> None:
        data = self._load_db()
        if account_number in data:
            raise ValueError("Account already exists.")
        data[account_number] = {
            "name": name,
            "dob": dob,
            "soc": soc,
            "address": address,
            "email": email,
            "balance": balance,
            "history": [],
            "card": {
                "status": "active",
                "limit": card_limit,
                "merchants": {"enabled": [], "disabled": []},
                "travel_limits": []
            }
        }
        self._save_db(data)

    def validate_customer(self, name: str, dob: str, soc: str, address: str, account_number: str) -> bool:
        data = self._load_db()
        acc = data.get(account_number)
        if not acc:
            return False

        prompt = f"""
Compare this provided user info to the record.
Return only yes if they appear to match, even if there are small formatting differences, otherwise no.

Provided info:
Name: {name}
DOB: {dob}
SOC: {soc}
Address: {address}

Record info:
Name: {acc['name']}
DOB: {acc['dob']}
SOC: {acc['soc']}
Address: {acc['address']}

ONLY RESPOND WITH yes or no
"""
        response = self.client.responses.create(
            model="gpt-4.1",
            input=prompt,
            temperature=0.0
        )
        answer = (getattr(response, "output_text", "") or "").strip().lower()
        return "yes" in answer

    def get_balance(self, account_number: str) -> float:
        data = self._load_db()
        return data[account_number]["balance"]

    def get_spending_history(self, account_number: str) -> List[List[Any]]:
        data = self._load_db()
        acc = data[account_number]
        self._normalize_history(acc)
        return acc["history"]

    def send_report(self, account_number: str) -> str:
        data = self._load_db()
        acc = data[account_number]
        self._normalize_history(acc)
        report = f"Account Report for {acc['name']}\nBalance: ${acc['balance']}\nTransactions:\n"
        for ttype, amt, ts, desc, status in acc["history"]:
            report += f"{ts}  {ttype}  ${amt}  {desc}  [{status}]\n"
        return report

    def set_limit(self, account_number: str, new_limit: float) -> float:
        if new_limit < 0:
            raise ValueError("Limit cannot be negative")
        data, acc = self._get_account(account_number)
        self._ensure_card_fields(acc)
        acc["card"]["limit"] = new_limit
        self._save_db(data)
        return acc["card"]["limit"]

    def freeze_card(self, account_number: str) -> str:
        data, acc = self._get_account(account_number)
        self._ensure_card_fields(acc)
        acc["card"]["status"] = "frozen"
        self._save_db(data)
        return "frozen"

    def unlock_card(self, account_number: str) -> str:
        data, acc = self._get_account(account_number)
        self._ensure_card_fields(acc)
        acc["card"]["status"] = "active"
        self._save_db(data)
        return "active"

    def enable_merchant(self, account_number: str, merchant: str) -> Dict[str, List[str]]:
        data, acc = self._get_account(account_number)
        self._ensure_card_fields(acc)
        m = acc["card"]["merchants"]
        if merchant in m.get("disabled", []):
            m["disabled"].remove(merchant)
        if merchant not in m.get("enabled", []):
            m.setdefault("enabled", []).append(merchant)
        self._save_db(data)
        return {"enabled": m.get("enabled", []), "disabled": m.get("disabled", [])}

    def disable_merchant(self, account_number: str, merchant: str) -> Dict[str, List[str]]:
        data, acc = self._get_account(account_number)
        self._ensure_card_fields(acc)
        m = acc["card"]["merchants"]
        if merchant in m.get("enabled", []):
            m["enabled"].remove(merchant)
        if merchant not in m.get("disabled", []):
            m.setdefault("disabled", []).append(merchant)
        self._save_db(data)
        return {"enabled": m.get("enabled", []), "disabled": m.get("disabled", [])}

    def add_travel_limit(
        self,
        account_number: str,
        country: str,
        start: str,
        end: str,
        daily_cap: Optional[float] = None
    ) -> List[Dict[str, Any]]:
        data, acc = self._get_account(account_number)
        self._ensure_card_fields(acc)
        entry: Dict[str, Any] = {"country": country, "start": start, "end": end}
        if daily_cap is not None:
            if daily_cap < 0:
                raise ValueError("daily_cap cannot be negative")
            entry["daily_cap"] = daily_cap
        acc["card"]["travel_limits"].append(entry)
        self._save_db(data)
        return list(acc["card"]["travel_limits"])

    def get_card_status(self, account_number: str) -> str:
        _, acc = self._get_account(account_number)
        self._ensure_card_fields(acc)
        return acc["card"]["status"]

    def get_card_config(self, account_number: str) -> Dict[str, Any]:
        _, acc = self._get_account(account_number)
        self._ensure_card_fields(acc)
        return acc["card"]

    # New transaction support

    def list_transactions_by_date(
        self,
        account_number: str,
        date_iso: str,
        include_failed: bool = True
    ) -> List[Tuple[str, float, str, str, str]]:
        data, acc = self._get_account(account_number)
        self._normalize_history(acc)
        out: List[Tuple[str, float, str, str, str]] = []
        for ttype, amt, ts, desc, status in acc["history"]:
            if ts.startswith(date_iso):
                if include_failed or status != "failed":
                    out.append((ttype, float(amt), ts, desc, status))
        return out

    def list_failed_by_date(
        self,
        account_number: str,
        date_iso: str
    ) -> List[Tuple[str, float, str, str]]:
        data, acc = self._get_account(account_number)
        self._normalize_history(acc)
        out: List[Tuple[str, float, str, str]] = []
        for ttype, amt, ts, desc, status in acc["history"]:
            if ts.startswith(date_iso) and status == "failed":
                out.append((ttype, float(amt), ts, desc))
        return out

    def whitelist_merchant(self, account_number: str, merchant: str) -> Dict[str, Any]:
        data, acc = self._get_account(account_number)
        self._ensure_card_fields(acc)
        m = acc["card"]["merchants"]
        enabled = set(m.get("enabled", []))
        disabled = set(m.get("disabled", []))

        key = merchant.strip()
        if key in disabled:
            disabled.remove(key)
        enabled.add(key)

        m["enabled"] = sorted(enabled)
        m["disabled"] = sorted(disabled)
        self._save_db(data)
        return {"ok": True, "enabled": m["enabled"], "disabled": m["disabled"]}

    def add_failed_transaction(
        self,
        account_number: str,
        amount: float,
        timestamp_iso: str,
        merchant: str
    ) -> None:
        data, acc = self._get_account(account_number)
        self._normalize_history(acc)
        acc["history"].append(["Withdraw", float(amount), timestamp_iso, merchant, "failed"])
        self._save_db(data)

    def add_posted_transaction(
        self,
        account_number: str,
        ttype: str,
        amount: float,
        timestamp_iso: str,
        description: str
    ) -> None:
        if ttype not in {"Deposit", "Withdraw"}:
            raise ValueError("ttype must be Deposit or Withdraw")
        data, acc = self._get_account(account_number)
        self._normalize_history(acc)
        acc["history"].append([ttype, float(amount), timestamp_iso, description, "posted"])
        self._save_db(data)