Government & Elder Fraud Protection

class CaseworkerLookupTool {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://scamverify.ai/api/v1';
  }

  async callApi(endpoint, body) {
    const response = await fetch(`${this.baseUrl}${endpoint}`, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify(body),
    });
    if (!response.ok) throw new Error(`API error: ${response.status}`);
    return response.json();
  }

  async lookupPhone(phoneNumber) {
    const result = await this.callApi('/phone/lookup', {
      phone_number: phoneNumber,
    });

    return {
      number: phoneNumber,
      riskScore: result.risk_score,
      verdict: result.verdict,
      summary: result.explanation,
      details: {
        lineType: result.signals.line_type,
        carrier: result.signals.carrier,
        ftcComplaints: result.signals.ftc_complaints,
        robocallDetected: result.signals.robocall_detected,
      },
      // Plain-language recommendation for caseworkers
      recommendation: this.getPhoneRecommendation(result),
    };
  }

  async lookupUrl(url) {
    const result = await this.callApi('/url/lookup', { url });

    return {
      url,
      riskScore: result.risk_score,
      verdict: result.verdict,
      summary: result.explanation,
      recommendation: this.getUrlRecommendation(result),
    };
  }

  async analyzeMessage(messageText) {
    const result = await this.callApi('/text/analyze', {
      text: messageText,
    });

    return {
      riskScore: result.risk_score,
      verdict: result.verdict,
      summary: result.explanation,
      extractedPhones: result.signals.extracted_phones,
      extractedUrls: result.signals.extracted_urls,
      recommendation: this.getTextRecommendation(result),
    };
  }

  getPhoneRecommendation(result) {
    if (result.risk_score >= 70) {
      return 'HIGH RISK: This number has strong indicators of scam activity. Advise the caller not to answer or return calls from this number. Consider filing a report with the FTC.';
    }
    if (result.risk_score >= 40) {
      return 'MODERATE RISK: This number shows some concerning signals. Advise caution. If the caller has already shared personal information, recommend identity monitoring.';
    }
    if (result.signals.ftc_complaints > 0) {
      return `REPORTED: This number has ${result.signals.ftc_complaints} FTC complaint(s). Other consumers have reported it. Exercise caution.`;
    }
    return 'LOW RISK: No significant fraud indicators found for this number. However, the absence of reports does not guarantee safety.';
  }

  getUrlRecommendation(result) {
    if (result.verdict === 'phishing' || result.verdict === 'malware') {
      return 'DANGEROUS: This website has been identified as malicious. Advise the caller to avoid this site entirely and not enter any personal information. If they already have, recommend changing passwords and monitoring accounts.';
    }
    if (result.risk_score >= 50) {
      return 'SUSPICIOUS: This website shows fraud indicators. Advise the caller not to enter personal information or make payments through this site.';
    }
    return 'NO KNOWN THREATS: This website does not appear in our threat databases. This does not guarantee safety, but no known issues were found.';
  }

  getTextRecommendation(result) {
    if (result.risk_score >= 60) {
      return 'LIKELY SCAM: This message contains patterns consistent with known scam campaigns. Advise the caller not to respond and to block the sender.';
    }
    if (result.risk_score >= 30) {
      return 'SUSPICIOUS: This message contains some concerning elements. Advise the caller to verify through official channels before taking any action.';
    }
    return 'LOW RISK: No strong scam indicators detected. However, advise the caller to be cautious about unsolicited messages.';
  }
}

// Simple Express API for internal use
const tool = new CaseworkerLookupTool(process.env.SCAMVERIFY_API_KEY);

// Phone number lookup
app.post('/internal/lookup/phone', async (req, res) => {
  const result = await tool.lookupPhone(req.body.phone);
  res.json(result);
});

// URL lookup
app.post('/internal/lookup/url', async (req, res) => {
  const result = await tool.lookupUrl(req.body.url);
  res.json(result);
});

// Message analysis (text or email content a senior brings in)
app.post('/internal/analyze/message', async (req, res) => {
  const result = await tool.analyzeMessage(req.body.text);
  res.json(result);
});

import requests
import os

class CaseworkerLookupTool:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://scamverify.ai/api/v1"

    def _call_api(self, endpoint: str, body: dict) -> dict:
        response = requests.post(
            f"{self.base_url}{endpoint}",
            headers={
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json",
            },
            json=body,
        )
        response.raise_for_status()
        return response.json()

    def lookup_phone(self, phone_number: str) -> dict:
        result = self._call_api("/phone/lookup", {"phone_number": phone_number})

        if result["risk_score"] >= 70:
            recommendation = "HIGH RISK: Strong scam indicators. Advise caller to block this number."
        elif result["risk_score"] >= 40:
            recommendation = "MODERATE RISK: Exercise caution. Monitor for identity theft if info was shared."
        elif result["signals"]["ftc_complaints"] > 0:
            recommendation = f"REPORTED: {result['signals']['ftc_complaints']} FTC complaint(s) on file."
        else:
            recommendation = "LOW RISK: No significant fraud indicators found."

        return {
            "number": phone_number,
            "risk_score": result["risk_score"],
            "verdict": result["verdict"],
            "summary": result["explanation"],
            "line_type": result["signals"]["line_type"],
            "ftc_complaints": result["signals"]["ftc_complaints"],
            "recommendation": recommendation,
        }

    def lookup_url(self, url: str) -> dict:
        result = self._call_api("/url/lookup", {"url": url})
        return {
            "url": url,
            "risk_score": result["risk_score"],
            "verdict": result["verdict"],
            "summary": result["explanation"],
        }

    def analyze_message(self, text: str) -> dict:
        result = self._call_api("/text/analyze", {"text": text})
        return {
            "risk_score": result["risk_score"],
            "verdict": result["verdict"],
            "summary": result["explanation"],
            "extracted_phones": result["signals"]["extracted_phones"],
            "extracted_urls": result["signals"]["extracted_urls"],
        }

# Usage in a Flask app for internal caseworker tool
from flask import Flask, request, jsonify

app = Flask(__name__)
tool = CaseworkerLookupTool(os.environ["SCAMVERIFY_API_KEY"])

@app.route("/lookup/phone", methods=["POST"])
def lookup_phone():
    result = tool.lookup_phone(request.json["phone"])
    return jsonify(result)

@app.route("/lookup/url", methods=["POST"])
def lookup_url():
    result = tool.lookup_url(request.json["url"])
    return jsonify(result)