Spaces:
Sleeping
Sleeping
| """The agent loop. Given a counterparty, run a live web investigation: | |
| discover -> access -> extract -> sanitize, then hand the evidence to the | |
| verdict engine for the final APPROVE / ESCALATE / BLOCK decision.""" | |
| import brightdata_client | |
| import config | |
| import memory | |
| import reasoning | |
| import sanctions | |
| import sanitizer | |
| import scoring | |
| import verdict_engine | |
| def _build_queries(name: str) -> list: | |
| return [ | |
| f"{name} company official website", | |
| f"{name} fraud lawsuit sanction scam complaint fine", | |
| f"{name} reviews reputation supplier", | |
| ] | |
| def investigate(name: str, on_step=None) -> list: | |
| """Collect sanitized evidence about a counterparty. Returns a list of | |
| {url, content} dicts. on_step(msg) is an optional progress callback.""" | |
| def step(msg): | |
| if on_step: | |
| on_step(msg) | |
| evidence = [] | |
| seen_urls = set() | |
| serp_blob = [] | |
| for q in _build_queries(name): | |
| step(f"Searching: {q}") | |
| serp = brightdata_client.search_web(q) | |
| serp_blob.append(serp) | |
| combined = "\n".join(serp_blob) | |
| urls = brightdata_client.extract_urls(combined, limit=config.MAX_PAGES_TO_SCRAPE) | |
| for url in urls: | |
| if url in seen_urls: | |
| continue | |
| seen_urls.add(url) | |
| step(f"Reading: {url}") | |
| raw = brightdata_client.scrape_page(url) | |
| clean = sanitizer.sanitize(raw, config.MAX_EVIDENCE_CHARS) | |
| if clean: | |
| evidence.append({"url": url, "content": clean}) | |
| # If nothing was scrapeable, still pass the SERP summaries as evidence. | |
| if not evidence: | |
| step("No pages scraped; using search summaries as evidence.") | |
| evidence.append({ | |
| "url": "search-results", | |
| "content": sanitizer.sanitize(combined, config.MAX_EVIDENCE_CHARS), | |
| }) | |
| return evidence | |
| def run(name: str, amount: str = "", on_step=None) -> dict: | |
| """Full pipeline: sanctions screen -> investigate -> decide.""" | |
| def step(msg): | |
| if on_step: | |
| on_step(msg) | |
| # Step 0: sanctions screening. A confirmed hit is an immediate hard BLOCK — | |
| # no payment to a sanctioned entity, no matter what the web says. | |
| step("Screening against OFAC sanctions list...") | |
| sanc = sanctions.screen(name) | |
| if sanc["hit"]: | |
| step(f"SANCTIONS HIT: matches '{sanc['matched']}' on {sanc['source']}") | |
| decision = { | |
| "verdict": "BLOCK", | |
| "risk_score": 100, | |
| "confidence": "HIGH", | |
| "summary": (f"{name} matches a sanctioned entity on the " | |
| f"{sanc['source']} list. Payment is prohibited."), | |
| "factors": [{ | |
| "finding": (f"Name matches '{sanc['matched']}' on an official " | |
| f"sanctions list ({sanc['source']})."), | |
| "severity": "CRITICAL", | |
| "source": "https://ofac.treasury.gov/sanctions-list-service", | |
| }], | |
| "recommendation": ("Do NOT proceed. Transacting with a sanctioned " | |
| "party may be illegal. Escalate to compliance " | |
| "immediately."), | |
| } | |
| decision["breakdown"] = scoring.build_breakdown(decision, sanc) | |
| decision = reasoning.attach(decision, [], sanc) | |
| return {"name": name, "amount": amount, | |
| "evidence": [], "decision": decision, "sanctions": sanc} | |
| # No sanctions hit -> proceed with live web due diligence. | |
| evidence = investigate(name, on_step=on_step) | |
| step("Synthesizing verdict...") | |
| decision = verdict_engine.decide(name, amount, evidence) | |
| # Transparent score breakdown (explainability): how the number was reached. | |
| decision["breakdown"] = scoring.build_breakdown(decision, sanc) | |
| # Auditor reasoning: confidence, why-not-higher, contradiction check. | |
| decision = reasoning.attach(decision, evidence, sanc) | |
| # Memory: detect change vs the last time we checked this counterparty, | |
| # then store the new verdict. This is the continuous-monitoring layer. | |
| change = memory.diff(name, decision) | |
| if change and change["changed"]: | |
| step(f"Change since last check ({memory.backend_name()}): " | |
| f"{change['old_verdict']} -> {change['new_verdict']} " | |
| f"(risk {change['old_risk']} -> {change['new_risk']})") | |
| memory.remember(name, decision) | |
| return {"name": name, "amount": amount, "evidence": evidence, | |
| "decision": decision, "sanctions": sanc, "change": change} | |