sysops
595 lines
22 KiB
Python
595 lines
22 KiB
Python
"""Voice/browser/Telegram command router: export intel, webbuilder/agy, bevestiging + UI."""
|
|
from __future__ import annotations
|
|
|
|
import re
|
|
import time
|
|
import uuid
|
|
from typing import Any
|
|
|
|
import httpx
|
|
|
|
from app.config import settings
|
|
from app.services import webbuilder_agent
|
|
|
|
SESSION_TTL_SEC = 3600
|
|
_pending: dict[str, dict[str, Any]] = {}
|
|
|
|
VOICE_CHANNELS = frozenset({"voice", "browser", "telegram"})
|
|
|
|
LOCATION_ALIASES: dict[str, dict[str, str]] = {
|
|
"dubai": {"country": "AE", "q": "Dubai", "label": "Dubai (VAE)"},
|
|
"abu dhabi": {"country": "AE", "q": "Abu Dhabi", "label": "Abu Dhabi (VAE)"},
|
|
"sharjah": {"country": "AE", "q": "Sharjah", "label": "Sharjah (VAE)"},
|
|
"vae": {"country": "AE", "q": "", "label": "Verenigde Arabische Emiraten"},
|
|
"uae": {"country": "AE", "q": "", "label": "Verenigde Arabische Emiraten"},
|
|
"emiraten": {"country": "AE", "q": "", "label": "VAE"},
|
|
"saudi": {"country": "SA", "q": "", "label": "Saoedi-Arabië"},
|
|
"riyadh": {"country": "SA", "q": "Riyadh", "label": "Riyadh (SA)"},
|
|
"jeddah": {"country": "SA", "q": "Jeddah", "label": "Jeddah (SA)"},
|
|
"qatar": {"country": "QA", "q": "", "label": "Qatar"},
|
|
"doha": {"country": "QA", "q": "Doha", "label": "Doha (Qatar)"},
|
|
"kuwait": {"country": "KW", "q": "", "label": "Koeweit"},
|
|
"nederland": {"country": "NL", "q": "", "label": "Nederland"},
|
|
"amsterdam": {"country": "NL", "q": "Amsterdam", "label": "Amsterdam"},
|
|
"rotterdam": {"country": "NL", "q": "Rotterdam", "label": "Rotterdam"},
|
|
"belgië": {"country": "BE", "q": "", "label": "België"},
|
|
"belgie": {"country": "BE", "q": "", "label": "België"},
|
|
"antwerpen": {"country": "BE", "q": "Antwerp", "label": "Antwerpen"},
|
|
"duitsland": {"country": "DE", "q": "", "label": "Duitsland"},
|
|
"berlijn": {"country": "DE", "q": "Berlin", "label": "Berlijn"},
|
|
"frankfurt": {"country": "DE", "q": "Frankfurt", "label": "Frankfurt"},
|
|
"turkije": {"country": "TR", "q": "", "label": "Turkije"},
|
|
"istanbul": {"country": "TR", "q": "Istanbul", "label": "Istanbul"},
|
|
"marokko": {"country": "MA", "q": "", "label": "Marokko"},
|
|
"casablanca": {"country": "MA", "q": "Casablanca", "label": "Casablanca"},
|
|
}
|
|
|
|
ENTITY_ALIASES: dict[str, str] = {
|
|
"distri": "distributor,wholesaler,importer,logistics",
|
|
"distributeur": "distributor,wholesaler,importer,logistics",
|
|
"distributeurs": "distributor,wholesaler,importer,logistics",
|
|
"groothandel": "wholesaler,distributor",
|
|
"groothandels": "wholesaler,distributor",
|
|
"importeur": "importer",
|
|
"importeurs": "importer",
|
|
"logistiek": "logistics",
|
|
"restaurant": "restaurant",
|
|
"restaurants": "restaurant",
|
|
"cateraar": "caterer",
|
|
"cateraars": "caterer",
|
|
"slager": "butcher",
|
|
"slagers": "butcher",
|
|
"döner": "doner",
|
|
"doner": "doner",
|
|
}
|
|
|
|
SEARCH_TRIGGERS = (
|
|
"zoek", "opzoeken", "vind", "zoeken", "toon", "laat zien", "lijst",
|
|
"geef me", "haal op", "export intel", "wereldexport",
|
|
)
|
|
|
|
YES_RE = re.compile(
|
|
r"^(ja|jawel|jep|yep|ok|oke|oké|okay|klopt|bevestig|doe maar|graag|precies|goed|akkoord|start|uitvoeren|doorgaan)\b",
|
|
re.I,
|
|
)
|
|
NO_RE = re.compile(r"^(nee|neen|stop|annuleer|niet|cancel|laat maar|wacht)\b", re.I)
|
|
|
|
|
|
def _cleanup_sessions() -> None:
|
|
now = time.time()
|
|
dead = [k for k, v in _pending.items() if now - float(v.get("_ts", 0)) > SESSION_TTL_SEC]
|
|
for k in dead:
|
|
_pending.pop(k, None)
|
|
|
|
|
|
def is_confirmation_yes(text: str) -> bool:
|
|
t = (text or "").strip()
|
|
return bool(t and YES_RE.search(t))
|
|
|
|
|
|
def is_confirmation_no(text: str) -> bool:
|
|
t = (text or "").strip()
|
|
return bool(t and NO_RE.search(t))
|
|
|
|
|
|
def wants_export_search(text: str) -> bool:
|
|
t = (text or "").lower()
|
|
if not any(k in t for k in SEARCH_TRIGGERS):
|
|
return False
|
|
has_loc = any(alias in t for alias in LOCATION_ALIASES)
|
|
has_ent = any(alias in t for alias in ENTITY_ALIASES)
|
|
return has_loc or has_ent
|
|
|
|
|
|
def _detect_location(text: str) -> dict[str, str] | None:
|
|
t = text.lower()
|
|
best: tuple[int, dict[str, str]] | None = None
|
|
for alias, loc in LOCATION_ALIASES.items():
|
|
if alias in t:
|
|
score = len(alias)
|
|
if best is None or score > best[0]:
|
|
best = (score, loc)
|
|
return best[1] if best else None
|
|
|
|
|
|
def _detect_entity_types(text: str) -> str:
|
|
t = text.lower()
|
|
found: list[str] = []
|
|
for alias, types in ENTITY_ALIASES.items():
|
|
if alias in t:
|
|
for et in types.split(","):
|
|
if et not in found:
|
|
found.append(et)
|
|
if not found and any(w in t for w in ("distri", "distributeur", "groothandel", "b2b", "leverancier")):
|
|
return "distributor,wholesaler,importer,logistics"
|
|
return ",".join(found) if found else "distributor,wholesaler,importer,logistics"
|
|
|
|
|
|
def _entity_label(entity_types: str) -> str:
|
|
labels = {
|
|
"distributor": "distributeurs",
|
|
"wholesaler": "groothandels",
|
|
"importer": "importeurs",
|
|
"logistics": "logistiek",
|
|
"restaurant": "restaurants",
|
|
"caterer": "cateraars",
|
|
"butcher": "slagers",
|
|
"doner": "dönerzaken",
|
|
}
|
|
parts = [labels.get(x.strip(), x.strip()) for x in entity_types.split(",") if x.strip()]
|
|
return ", ".join(parts) if parts else "bedrijven"
|
|
|
|
|
|
def parse_export_search(text: str) -> dict[str, Any]:
|
|
loc = _detect_location(text)
|
|
entity_types = _detect_entity_types(text)
|
|
missing: list[str] = []
|
|
if not loc:
|
|
missing.append("locatie")
|
|
params: dict[str, Any] = {
|
|
"country": (loc or {}).get("country", ""),
|
|
"q": (loc or {}).get("q", ""),
|
|
"entity_types": entity_types,
|
|
"limit": 50,
|
|
}
|
|
label_loc = (loc or {}).get("label", "")
|
|
return {
|
|
"params": params,
|
|
"location_label": label_loc,
|
|
"entity_label": _entity_label(entity_types),
|
|
"missing": missing,
|
|
"incomplete": bool(missing),
|
|
}
|
|
|
|
|
|
def store_pending(session_id: str, action: dict[str, Any]) -> str:
|
|
_cleanup_sessions()
|
|
action_id = str(uuid.uuid4())[:12]
|
|
action = dict(action)
|
|
action["id"] = action_id
|
|
action["_ts"] = time.time()
|
|
_pending[session_id] = action
|
|
return action_id
|
|
|
|
|
|
def get_pending(session_id: str) -> dict[str, Any] | None:
|
|
_cleanup_sessions()
|
|
row = _pending.get(session_id)
|
|
if not row:
|
|
return None
|
|
if time.time() - float(row.get("_ts", 0)) > SESSION_TTL_SEC:
|
|
_pending.pop(session_id, None)
|
|
return None
|
|
return row
|
|
|
|
|
|
def clear_pending(session_id: str) -> None:
|
|
_pending.pop(session_id, None)
|
|
|
|
|
|
def build_confirmation_question(parsed: dict[str, Any]) -> str:
|
|
loc = parsed.get("location_label") or "de geselecteerde regio"
|
|
ent = parsed.get("entity_label") or "bedrijven"
|
|
return (
|
|
f"Ik ga **{ent}** in **{loc}** voor je opzoeken in Export Intel.\n\n"
|
|
"Klopt dat? Zeg **ja** om te starten, **nee** om te annuleren, "
|
|
"of geef aan wat ik moet aanpassen (bijv. alleen distributeurs, of een andere stad)."
|
|
)
|
|
|
|
|
|
def build_clarification_question(parsed: dict[str, Any]) -> str:
|
|
missing = parsed.get("missing") or []
|
|
if "locatie" in missing:
|
|
return (
|
|
"In welke **stad of welk land** wil je zoeken? "
|
|
"Bijvoorbeeld: Dubai, VAE, Nederland, Frankfurt…"
|
|
)
|
|
return "Kun je iets specifieker zijn over wat je zoekt en waar?"
|
|
|
|
|
|
async def fetch_export_entities(params: dict[str, Any]) -> dict[str, Any]:
|
|
query = {k: v for k, v in params.items() if v not in (None, "")}
|
|
url = f"{settings.TOOLS_API_URL.rstrip('/')}/export-intel/entities"
|
|
async with httpx.AsyncClient(timeout=60.0) as client:
|
|
resp = await client.get(url, params=query)
|
|
resp.raise_for_status()
|
|
return resp.json()
|
|
|
|
|
|
def _open_url(params: dict[str, Any]) -> str:
|
|
qs = []
|
|
if params.get("country"):
|
|
qs.append(f"country={params['country']}")
|
|
if params.get("q"):
|
|
qs.append(f"q={params['q']}")
|
|
qs.append("tab=distributors")
|
|
return "/export-intel?" + "&".join(qs)
|
|
|
|
|
|
async def execute_search_action(action: dict[str, Any]) -> dict[str, Any]:
|
|
params = action.get("params") or {}
|
|
data = await fetch_export_entities(params)
|
|
items = data.get("items") or []
|
|
total = int(data.get("total") or len(items))
|
|
loc = action.get("location_label") or params.get("q") or params.get("country") or "markt"
|
|
ent = action.get("entity_label") or "bedrijven"
|
|
title = f"{ent.title()} — {loc}"
|
|
if not items:
|
|
reply = (
|
|
f"Ik heb gezocht maar vond **geen** {ent} in {loc}. "
|
|
"Wil je dat ik een sync start of een bredere regio probeer?"
|
|
)
|
|
else:
|
|
reply = (
|
|
f"Gevonden: **{total}** {ent} in {loc}. "
|
|
f"Ik toon de eerste {min(len(items), 50)} in het resultatenvenster."
|
|
)
|
|
return {
|
|
"agent": "sourcing",
|
|
"agent_label": "Export Intel → Herman",
|
|
"reply": reply,
|
|
"delegated_agents": ["sourcing", "export_intel"],
|
|
"routing_reason": f"Export Intel zoekopdracht: {title}",
|
|
"agent_steps": [
|
|
{"agent": "export_intel", "status": "done", "message": f"{total} resultaten"},
|
|
{"agent": "sourcing", "status": "delegated", "message": "Marktdata opgehaald"},
|
|
],
|
|
"needs_confirmation": False,
|
|
"ui_actions": [
|
|
{
|
|
"type": "show_export_results",
|
|
"title": title,
|
|
"entities": items[:50],
|
|
"total": total,
|
|
"params": params,
|
|
"open_url": _open_url(params),
|
|
}
|
|
],
|
|
}
|
|
|
|
|
|
def _pending_summary(action: dict[str, Any]) -> dict[str, Any]:
|
|
atype = action.get("type", "")
|
|
base = {"id": action.get("id"), "type": atype}
|
|
if atype == "export_intel_search":
|
|
base["location_label"] = action.get("location_label")
|
|
base["entity_label"] = action.get("entity_label")
|
|
base["params"] = action.get("params")
|
|
elif atype == "webbuilder_build":
|
|
base["project"] = action.get("project")
|
|
base["entity_label"] = f"website {action.get('project', '')}"
|
|
base["location_label"] = "Agy · Antigravity"
|
|
return base
|
|
|
|
|
|
def build_webbuilder_confirmation(project: str, raw: str) -> str:
|
|
snippet = (raw or "")[:240]
|
|
return (
|
|
f"Ik stuur **Agy (Antigravity)** op Hermes aan om een website te bouwen.\n\n"
|
|
f"**Project:** {project}\n"
|
|
f"**Opdracht:** {snippet}{'…' if len(raw or '') > 240 else ''}\n\n"
|
|
"Klopt dat? Zeg **ja** om te starten, **nee** om te annuleren."
|
|
)
|
|
|
|
|
|
async def execute_webbuilder_action(action: dict[str, Any], channel: str = "voice") -> dict[str, Any]:
|
|
raw = action.get("raw_message") or ""
|
|
project = action.get("project") or webbuilder_agent.extract_project_name(raw)
|
|
try:
|
|
outcome = await webbuilder_agent.generate_from_message(raw, channel=channel, wait=False)
|
|
except Exception as exc:
|
|
return {
|
|
"agent": "webbuilder",
|
|
"agent_label": "Web Builder",
|
|
"reply": f"Agy kon niet starten op Hermes: {exc}\n\nControleer VM107 webbuilder-api (:8798).",
|
|
"delegated_agents": ["webbuilder"],
|
|
"needs_confirmation": False,
|
|
}
|
|
|
|
project = outcome.get("project") or project
|
|
preview = outcome.get("preview_url") or webbuilder_agent.HERMES_PREVIEW_BASE
|
|
nas_path = outcome.get("nas_path") or ""
|
|
reply = (
|
|
f"Agy is gestart voor **{project}**.\n"
|
|
f"Preview (na build): {preview}\n"
|
|
f"NAS: {nas_path}\n"
|
|
"Volg live: Agents → Terminals → Web Builder."
|
|
)
|
|
return {
|
|
"agent": "webbuilder",
|
|
"agent_label": "Agy / Web Builder → Herman",
|
|
"reply": reply,
|
|
"delegated_agents": ["webbuilder"],
|
|
"routing_reason": "Website via Antigravity CLI (agy) op Hermes VM107",
|
|
"agent_steps": [
|
|
{"agent": "webbuilder", "status": "running", "message": f"agy bouwt {project}"},
|
|
{"agent": "herman", "status": "delegated", "message": "Voice → build gestart"},
|
|
],
|
|
"webbuilder_project": project,
|
|
"webbuilder_preview_url": preview,
|
|
"needs_confirmation": False,
|
|
"ui_actions": [
|
|
{
|
|
"type": "open_webbuilder_build",
|
|
"title": f"Website build — {project}",
|
|
"project": project,
|
|
"preview_url": preview,
|
|
"nas_path": nas_path,
|
|
"agents_url": "/agents",
|
|
"status_hint": "Build duurt enkele minuten — preview opent na afloop",
|
|
}
|
|
],
|
|
}
|
|
|
|
|
|
async def execute_pending_action(action: dict[str, Any], channel: str = "voice") -> dict[str, Any]:
|
|
atype = action.get("type")
|
|
if atype == "webbuilder_build":
|
|
return await execute_webbuilder_action(action, channel=channel)
|
|
return await execute_search_action(action)
|
|
|
|
|
|
def _confirmation_reminder(pending: dict[str, Any]) -> str:
|
|
if pending.get("type") == "webbuilder_build":
|
|
return build_webbuilder_confirmation(pending.get("project", "website"), pending.get("raw_message", ""))
|
|
return build_confirmation_question(pending)
|
|
|
|
|
|
async def handle_voice_command(
|
|
message: str,
|
|
session_id: str | None = None,
|
|
confirm_action_id: str | None = None,
|
|
channel: str = "voice",
|
|
) -> dict[str, Any] | None:
|
|
"""Unified voice/browser router: bevestiging + export + webbuilder/agy."""
|
|
sid = (session_id or "").strip() or "default"
|
|
text = (message or "").strip()
|
|
if not text:
|
|
return None
|
|
|
|
pending = get_pending(sid)
|
|
|
|
if confirm_action_id and pending and pending.get("id") == confirm_action_id:
|
|
clear_pending(sid)
|
|
return await execute_pending_action(pending, channel=channel)
|
|
|
|
if pending:
|
|
if is_confirmation_yes(text):
|
|
clear_pending(sid)
|
|
return await execute_pending_action(pending, channel=channel)
|
|
if is_confirmation_no(text):
|
|
clear_pending(sid)
|
|
return {
|
|
"agent": "herman",
|
|
"agent_label": "Herman",
|
|
"reply": "Oké, geannuleerd. Waar kan ik je verder mee helpen?",
|
|
"needs_confirmation": False,
|
|
}
|
|
if pending.get("awaiting") == "location" and pending.get("type") == "export_intel_search":
|
|
loc = _detect_location(text)
|
|
if loc:
|
|
merged = dict(pending)
|
|
merged["params"] = dict(pending.get("params") or {})
|
|
merged["params"]["country"] = loc["country"]
|
|
merged["params"]["q"] = loc.get("q", "")
|
|
merged["location_label"] = loc["label"]
|
|
merged.pop("awaiting", None)
|
|
merged.pop("incomplete", None)
|
|
merged.pop("missing", None)
|
|
action_id = store_pending(sid, merged)
|
|
return {
|
|
"agent": "herman",
|
|
"agent_label": "Herman",
|
|
"reply": build_confirmation_question(merged),
|
|
"needs_confirmation": True,
|
|
"pending_action": _pending_summary(merged),
|
|
}
|
|
return {
|
|
"agent": "herman",
|
|
"agent_label": "Herman",
|
|
"reply": build_clarification_question({"missing": ["locatie"]}),
|
|
"needs_confirmation": True,
|
|
"clarification": True,
|
|
}
|
|
if webbuilder_agent.wants_website(text):
|
|
project = webbuilder_agent.extract_project_name(text)
|
|
action_id = store_pending(sid, {
|
|
"type": "webbuilder_build",
|
|
"project": project,
|
|
"raw_message": text,
|
|
})
|
|
return {
|
|
"agent": "herman",
|
|
"agent_label": "Herman",
|
|
"reply": build_webbuilder_confirmation(project, text),
|
|
"needs_confirmation": True,
|
|
"pending_action": _pending_summary(get_pending(sid) or {}),
|
|
}
|
|
if wants_export_search(text):
|
|
parsed = parse_export_search(text)
|
|
if not parsed.get("incomplete"):
|
|
action_id = store_pending(sid, {**parsed, "type": "export_intel_search"})
|
|
return {
|
|
"agent": "herman",
|
|
"agent_label": "Herman",
|
|
"reply": build_confirmation_question(parsed),
|
|
"needs_confirmation": True,
|
|
"pending_action": _pending_summary(get_pending(sid) or {}),
|
|
}
|
|
return {
|
|
"agent": "herman",
|
|
"agent_label": "Herman",
|
|
"reply": (
|
|
f"Ik wacht nog op bevestiging.\n\n{_confirmation_reminder(pending)}\n\n"
|
|
"Zeg **ja** of **nee**."
|
|
),
|
|
"needs_confirmation": True,
|
|
"pending_action": _pending_summary(pending),
|
|
}
|
|
|
|
if webbuilder_agent.wants_website(text):
|
|
project = webbuilder_agent.extract_project_name(text)
|
|
store_pending(sid, {"type": "webbuilder_build", "project": project, "raw_message": text})
|
|
pa = get_pending(sid) or {}
|
|
return {
|
|
"agent": "herman",
|
|
"agent_label": "Herman",
|
|
"reply": build_webbuilder_confirmation(project, text),
|
|
"needs_confirmation": True,
|
|
"pending_action": _pending_summary(pa),
|
|
}
|
|
|
|
return await handle_export_intent(message, session_id=session_id, confirm_action_id=confirm_action_id)
|
|
|
|
|
|
async def handle_export_intent(
|
|
message: str,
|
|
session_id: str | None = None,
|
|
confirm_action_id: str | None = None,
|
|
) -> dict[str, Any] | None:
|
|
"""Return Herman-shaped dict when export flow applies, else None."""
|
|
sid = (session_id or "").strip() or "default"
|
|
text = (message or "").strip()
|
|
if not text:
|
|
return None
|
|
|
|
pending = get_pending(sid)
|
|
|
|
if confirm_action_id and pending and pending.get("id") == confirm_action_id:
|
|
clear_pending(sid)
|
|
return await execute_pending_action(pending)
|
|
|
|
if pending:
|
|
if is_confirmation_yes(text):
|
|
clear_pending(sid)
|
|
return await execute_pending_action(pending)
|
|
if is_confirmation_no(text):
|
|
clear_pending(sid)
|
|
return {
|
|
"agent": "herman",
|
|
"agent_label": "Herman",
|
|
"reply": "Oké, geannuleerd. Waar kan ik je verder mee helpen?",
|
|
"needs_confirmation": False,
|
|
}
|
|
if pending.get("awaiting") == "location":
|
|
loc = _detect_location(text)
|
|
if loc:
|
|
merged = dict(pending)
|
|
merged["params"] = dict(pending.get("params") or {})
|
|
merged["params"]["country"] = loc["country"]
|
|
merged["params"]["q"] = loc.get("q", "")
|
|
merged["location_label"] = loc["label"]
|
|
merged.pop("awaiting", None)
|
|
merged.pop("incomplete", None)
|
|
merged.pop("missing", None)
|
|
action_id = store_pending(sid, merged)
|
|
return {
|
|
"agent": "herman",
|
|
"agent_label": "Herman",
|
|
"reply": build_confirmation_question(merged),
|
|
"needs_confirmation": True,
|
|
"pending_action": {
|
|
"id": action_id,
|
|
"type": "export_intel_search",
|
|
"params": merged.get("params"),
|
|
"location_label": merged.get("location_label"),
|
|
"entity_label": merged.get("entity_label"),
|
|
},
|
|
}
|
|
return {
|
|
"agent": "herman",
|
|
"agent_label": "Herman",
|
|
"reply": build_clarification_question({"missing": ["locatie"]}),
|
|
"needs_confirmation": True,
|
|
"clarification": True,
|
|
}
|
|
if wants_export_search(text):
|
|
parsed = parse_export_search(text)
|
|
if parsed.get("incomplete"):
|
|
return {
|
|
"agent": "herman",
|
|
"agent_label": "Herman",
|
|
"reply": build_clarification_question(parsed),
|
|
"needs_confirmation": True,
|
|
"clarification": True,
|
|
}
|
|
action_id = store_pending(sid, parsed)
|
|
return {
|
|
"agent": "herman",
|
|
"agent_label": "Herman",
|
|
"reply": build_confirmation_question(parsed),
|
|
"needs_confirmation": True,
|
|
"pending_action": {
|
|
"id": action_id,
|
|
"type": "export_intel_search",
|
|
"params": parsed.get("params"),
|
|
"location_label": parsed.get("location_label"),
|
|
"entity_label": parsed.get("entity_label"),
|
|
},
|
|
}
|
|
return {
|
|
"agent": "herman",
|
|
"agent_label": "Herman",
|
|
"reply": (
|
|
f"Ik wacht nog op bevestiging: {build_confirmation_question(pending)}\n\n"
|
|
"Zeg **ja** of **nee**, of stel een nieuwe zoekopdracht."
|
|
),
|
|
"needs_confirmation": True,
|
|
"pending_action": {
|
|
"id": pending.get("id"),
|
|
"type": pending.get("type", "export_intel_search"),
|
|
"params": pending.get("params"),
|
|
"location_label": pending.get("location_label"),
|
|
"entity_label": pending.get("entity_label"),
|
|
},
|
|
}
|
|
|
|
if not wants_export_search(text):
|
|
return None
|
|
|
|
parsed = parse_export_search(text)
|
|
if parsed.get("incomplete"):
|
|
store_pending(sid, {**parsed, "type": "export_intel_search", "awaiting": "location"})
|
|
return {
|
|
"agent": "herman",
|
|
"agent_label": "Herman",
|
|
"reply": build_clarification_question(parsed),
|
|
"needs_confirmation": True,
|
|
"clarification": True,
|
|
}
|
|
|
|
action_id = store_pending(sid, {**parsed, "type": "export_intel_search"})
|
|
return {
|
|
"agent": "herman",
|
|
"agent_label": "Herman",
|
|
"reply": build_confirmation_question(parsed),
|
|
"needs_confirmation": True,
|
|
"pending_action": {
|
|
"id": action_id,
|
|
"type": "export_intel_search",
|
|
"params": parsed.get("params"),
|
|
"location_label": parsed.get("location_label"),
|
|
"entity_label": parsed.get("entity_label"),
|
|
},
|
|
}
|