"""
ReAct agent core (Phase 2) — thay one-shot Route bằng MỘT pydantic_ai Agent có
tool-calling tự quyết định. Mỗi module là một function tool; web_search/fetch_url
đăng ký thẳng. Sự kiện route/step phát ra NGAY trong hàm tool (chạy đồng bộ cùng
thread) qua callback `emit` trong Deps — giữ nguyên đường SSE hiện có.
Khác atria: không tự viết vòng while HTTP; dùng agent.run_sync + UsageLimits làm
số vòng tối đa. Text trả lời cuối của agent CHÍNH LÀ reply (hấp thụ narrate()).
"""
from __future__ import annotations
import datetime
import json
import random
import re
import threading
from dataclasses import dataclass, field
from pathlib import Path
from pydantic_ai import Agent, RunContext
from pydantic_ai.usage import UsageLimits
from .. import config
from ..memory import ConversationState
from ..tool_base import Tool, ToolResult
from ..web_search import web_search, fetch_url
from .llm import thinking_trace
from .prompts.composition import create_main_composer
TEMPLATES_DIR = Path(__file__).resolve().parent / "prompts" / "templates"
# Một lock toàn cục quanh tool.run() (browser Playwright chung) — CHỈ ôm phần chạy
# tool, không ôm LLM/web call. Thay cho _lock cả-request của webapp cũ.
TOOL_LOCK = threading.Lock()
STYLE_HINTS = (
"Ngắn gọn, đi thẳng vào việc.",
"Thân thiện, thêm chút hào hứng tự nhiên.",
"Điềm đạm, chuyên nghiệp, gọn gàng.",
"Súc tích một-hai câu là đủ.",
"Mô tả một chút về thứ vừa tạo cho sinh động.",
)
@dataclass
class Deps:
emit: object # callable(event: dict) -> None (SSE bridge)
attachment: str | None
transcript: str
catalog: str
style: str
today: str
# trạng thái tích luỹ trong lượt
routed: list = field(default_factory=list) # tên module đã gọi đầu tiên
last_data: dict = field(default_factory=dict) # data của tool result gần nhất
last_summary: str = "" # summary thô của tool gần nhất
any_ok: list = field(default_factory=list) # [True] nếu có tool thành công
any_fail: list = field(default_factory=list) # [True] nếu có tool thất bại
searched: bool = False # đã gọi web_search/fetch_url chưa
# Một số model Groq (llama) IN tool-call ra dưới dạng TEXT thay vì gọi thật, ví dụ
# {"task": "..."}
# ("...")
#
# Bắt lại để tự thực thi (fallback cho model không tool-call native).
_TEXT_CALL_NAME_RE = re.compile(
r"|>)", re.IGNORECASE | re.DOTALL)
# Câu hỏi THỜI SỰ rõ rệt: phải có dữ liệu web mới nhất, KHÔNG được trả lời từ trí nhớ.
# Model yếu (cerebras/gpt-oss effort thấp) hay lờ luật "phải search" -> lưới an toàn:
# nếu khớp mà agent KHÔNG search thì tự search rồi tổng hợp lại.
_TIME_SENSITIVE_RE = re.compile(
r"(tỉ số|tỷ số|kết quả|ai thắng|ai đang thắng|thắng mấy|mấy\s*[-–]\s*mấy|"
r"đang đá|đang diễn ra|trực tiếp|livescore|hiện tại|bây giờ|lúc này|hôm nay|"
r"tối nay|sáng nay|chiều nay|mới nhất|vừa xong|đang dẫn|bao nhiêu tuổi|"
r"giá.*(hôm nay|hiện tại|bây giờ)|thời tiết)",
re.IGNORECASE)
def _parse_text_call(text: str) -> tuple[str, str] | None:
"""Trả (tool_name, arg) nếu text là một tool-call bị in ra dạng chữ.
Args nằm sau tên (có thể sau dấu '>'): {"task"/"query"/"url":...} hoặc ("...")."""
m = _TEXT_CALL_NAME_RE.search(text or "")
if not m:
return None
name = m.group(1)
window = text[m.end():m.end() + 400]
arg = ""
j = window.find("{")
if j != -1: # dạng {"task"/"query"/"url": "..."}
try:
obj = json.loads(window[j:window.rfind("}") + 1])
arg = str(obj.get("task") or obj.get("query") or obj.get("url") or "").strip()
except Exception:
arg = ""
if not arg: # dạng ("...") hoặc "..."
m2 = re.search(r'["\']([^"\']{2,})["\']', window)
arg = m2.group(1).strip() if m2 else ""
return (name, arg)
def _observe(res: ToolResult) -> str:
"""Rút gọn ToolResult thành observation cho LLM (tiết kiệm token)."""
head = "OK" if res.ok else "LỖI"
summary = (res.summary or "").strip().replace("\n", " ")[:400]
arts = []
if isinstance(res.data, dict):
for k in ("gcode_file", "stl_file", "video", "image", "screenshot", "file"):
v = res.data.get(k)
if isinstance(v, str):
arts.append(v.replace("\\", "/").rsplit("/", 1)[-1])
tail = f" | tệp: {', '.join(arts)}" if arts else ""
# Khi LỖI: nhắc agent truyền đạt ĐÚNG lý do + gợi ý của công cụ cho người dùng,
# đừng tự bịa nguyên nhân khác (vd tool báo "đang chạy cloud nên không thấy máy
# in" mà agent lại nói "máy in bị tắt").
hint = "" if res.ok else (" || Nhắc: nói lại cho người dùng ĐÚNG lý do và gợi ý ở trên, "
"GIỮ nguyên ý (kể cả cách khắc phục), ĐỪNG tự bịa nguyên nhân khác.")
return f"{head}: {summary}{tail}{hint}"
class ReactAgent:
"""Bọc một pydantic_ai Agent có: module tools + web_search/fetch_url + system
prompt ghép từ template. Dùng lại cho mọi lượt; deps mang ngữ cảnh từng lượt."""
def __init__(self, model_name: str, tools: dict[str, Tool]):
self.model_name = model_name
self.tools = tools
self._composer = create_main_composer(TEMPLATES_DIR)
self._static_prompt = self._composer.compose({})
self._max_requests = config.REACT_MAX_REQUESTS
self._build()
# ---- catalog (mô tả module cho system prompt, từ SKILL.md) ----
def _catalog(self) -> str:
from ..modules.registry import get_registry
lines = []
reg_by_name = {m.name: m for m in get_registry().all()}
for name in self.tools:
m = reg_by_name.get(name)
if m is None:
lines.append(f"### {name}\n{self.tools[name].description}")
continue
# SKILL.md đã bỏ frontmatter; cắt ~550 ký tự để giữ token nhỏ (Groq free TPM).
_, body = _split_frontmatter(m.skill_md)
lines.append(body.strip()[:550])
return "## Công cụ hiện có\n\n" + "\n\n".join(lines)
def _build(self) -> None:
model = config.pydantic_model(self.model_name)
# Effort THẤP cho ReAct: vòng lặp đã lo phần suy luận nhiều bước; reasoning
# nặng mỗi request chỉ làm chậm (mỗi vòng gpt-oss ~28s ở medium).
settings = config.reasoning_settings(self.model_name, effort=config.REACT_REASONING_EFFORT)
agent = Agent(model, deps_type=Deps, model_settings=settings,
instructions=self._static_prompt)
@agent.instructions
def _dynamic(ctx: RunContext[Deps]) -> str:
parts = [ctx.deps.catalog,
f"Bây giờ là {ctx.deps.today}. Dùng mốc này để biết sự kiện nào ĐÃ "
"diễn ra (giờ đã qua) và cái nào SẮP tới.", ctx.deps.style]
if ctx.deps.transcript:
parts.append("## Lịch sử hội thoại\n" + ctx.deps.transcript)
if ctx.deps.attachment:
ext = ctx.deps.attachment.lower().rsplit(".", 1)[-1]
parts.append(f"(Người dùng vừa đính kèm một file .{ext}. "
"Định tuyến theo đuôi file như hướng dẫn.)")
return "\n\n".join(p for p in parts if p)
# web grounding tools — bọc qua ctx để ĐÁNH DẤU deps.searched (biết agent đã
# tra web chưa, phục vụ lưới an toàn thời sự). strict=False đồng nhất trên MỌI
# tool: Cerebras (OpenAI-compat) cấm trộn strict true/false giữa các tool.
def _web_search(ctx: RunContext[Deps], query: str) -> str:
"""Tra cứu web để lấy thông tin MỚI/thời sự (tin tức, tỉ số, giá, 'hiện tại').
Trả về tiêu đề + trích đoạn + link. Cần chi tiết thì fetch_url link phù hợp."""
ctx.deps.searched = True
return web_search(query)
def _fetch_url(ctx: RunContext[Deps], url: str) -> str:
"""Đọc nội dung THẬT của một URL rồi trả về văn bản (không đoán từ tiêu đề)."""
ctx.deps.searched = True
return fetch_url(url)
agent.tool(_web_search, name="web_search", strict=False)
agent.tool(_fetch_url, name="fetch_url", strict=False)
# mỗi module -> một function tool run_
for name, tool in self.tools.items():
self._register_module_tool(agent, name, tool)
self.agent = agent
def _exec_module(self, name: str, task: str, deps: Deps) -> ToolResult:
"""Chạy một module tool: phát route/step, ôm TOOL_LOCK, cập nhật deps."""
tool = self.tools[name]
emit = deps.emit
if not deps.routed: # phát route chip ở lần gọi module đầu
deps.routed.append(name)
if callable(emit):
emit({"type": "route", "tool": name, "reason": "agent chọn công cụ"})
if callable(emit):
emit({"type": "step", "kind": "running", "name": tool.name, "machine": name})
def on_progress(ev):
if callable(emit):
emit({"type": "step", **ev})
try:
with TOOL_LOCK: # serialize browser Playwright dùng chung
res = tool.run(task, attachment=deps.attachment, on_progress=on_progress)
except Exception as e:
res = ToolResult(ok=False, summary=f"Lỗi khi chạy {name}: {e}")
deps.last_data = res.data if isinstance(res.data, dict) else {}
deps.last_summary = res.summary or ""
(deps.any_ok if res.ok else deps.any_fail).append(True)
if callable(emit):
emit({"type": "step", "kind": "done", "name": tool.name, "machine": name,
"status": "ok" if res.ok else "fail", "detail": (res.summary or "")[:200]})
return res
def _register_module_tool(self, agent: Agent, name: str, tool: Tool) -> None:
desc = (tool.description or name).strip().split("\n")[0][:180]
def _run_module(ctx: RunContext[Deps], task: str) -> str:
return _observe(self._exec_module(name, task, ctx.deps))
_run_module.__name__ = f"run_{name}"
_run_module.__doc__ = f"{desc}\n\nArgs:\n task: yêu cầu cụ thể cho công cụ {name}."
agent.tool(_run_module, name=f"run_{name}", strict=False)
def _text_web_fallback(self, tool_name: str, arg: str, message: str) -> str:
"""llama in web_search/fetch_url ra chữ -> chạy thật rồi tổng hợp MỘT lần
bằng agent không-tool (tránh lại đẻ ra text-call)."""
try:
data = fetch_url(arg) if tool_name == "fetch_url" else web_search(arg or message)
except Exception:
return "Xin lỗi, mình chưa lấy được thông tin đáng tin cậy cho câu này."
try:
now_vn = (datetime.datetime.now(datetime.timezone.utc)
+ datetime.timedelta(hours=7)).strftime("%Y-%m-%d %H:%M")
plain = Agent(config.pydantic_model(self.model_name), instructions=(
f"Bây giờ là {now_vn} (giờ Việt Nam). Trả lời NGẮN GỌN bằng tiếng Việt DỰA "
"HOÀN TOÀN vào dữ liệu web bên dưới. KHÔNG gọi công cụ, KHÔNG bịa tỉ số/số "
"liệu. Quy tắc cho tin thể thao/tỉ số: nếu dữ liệu CÓ tỉ số thì nêu tỉ số + "
"nguồn, và nếu nguồn ghi 'LIVE'/'đang đá'/còn phút thi đấu thì NÓI RÕ 'trận "
"đang diễn ra, tỉ số có thể đã đổi — xem trực tiếp để cập nhật'. Nếu các "
"nguồn cho tỉ số KHÁC nhau (trận live), lấy tỉ số ở nguồn MỚI/CAO nhất. "
"Nếu dữ liệu chỉ có LỊCH mà KHÔNG có tỉ số, nói trung tính 'chưa tra được tỉ "
"số chính thức', đừng tự phán trận 'chưa diễn ra' hay 'đã xong'. Thiếu dữ "
"liệu thì nói thẳng là chưa chắc."))
out = plain.run_sync(f"Câu hỏi: {message}\n\n[Dữ liệu web]:\n{data[:2500]}").output
return (out or "").strip() or data[:500]
except Exception:
return data[:500]
# ---- API dùng bởi facade Harness ----
def stream(self, message: str, state: ConversationState | None,
attachment: str | None, emit) -> ToolResult:
"""Chạy một lượt ReAct, phát sự kiện qua emit, trả ToolResult cuối."""
from .. import usage as _usage
_usage.reset() # đếm token của lượt này (cùng thread worker)
transcript = state.transcript() if (state and state.turns) else ""
# Giờ VIỆT NAM (UTC+7): server HF chạy giờ UTC. Có GIỜ hiện tại thì model mới
# phân biệt được trận "đã đá" (giờ đã qua) vs "sắp/đang đá tối nay".
now_vn = datetime.datetime.now(datetime.timezone.utc) + datetime.timedelta(hours=7)
deps = Deps(emit=emit, attachment=attachment, transcript=transcript,
catalog=self._catalog(), style=random.choice(STYLE_HINTS),
today=now_vn.strftime("%Y-%m-%d %H:%M") + " (giờ Việt Nam, UTC+7)")
limits = UsageLimits(request_limit=self._max_requests)
reasoning = ""
try:
# KHÔNG dùng run_with_retry ở top-level: retry sẽ chạy LẠI tool từ đầu.
# Một lần chạy; 429 sau khi tool đã chạy được handler dưới cứu last_data.
res = self.agent.run_sync(message, deps=deps, usage_limits=limits)
text = (res.output or "").strip()
reasoning = thinking_trace(res)
from .. import usage as _usage
_usage.add(res.usage) # cả vòng ReAct (mọi iteration) trong 1 lần
except Exception as e:
from .llm import rate_limit_wait
# QUAN TRỌNG: nếu một công cụ ĐÃ chạy (có kết quả), phần việc đắt giá đã
# xong — chỉ bước tổng hợp NL cuối bị lỗi (429 TPM / hết vòng). Đừng vứt
# kết quả: trả summary thô của tool + artifacts để người dùng vẫn nhận được.
if deps.routed and (deps.any_ok or deps.last_data):
text = deps.last_summary or "Đã xử lý xong yêu cầu; kết quả sẵn bên dưới."
elif rate_limit_wait(str(e)) is not None:
return ToolResult(True, f"Model “{self.model_name}” đang bị nhà cung cấp giới hạn "
"tốc độ (rate limit). Thử lại sau một lát, hoặc bấm nút 🔌 "
"đổi sang nhà cung cấp/model khác (Groq, Cerebras, Gemini).",
{"kind": "chat"})
elif "request_limit" in str(e).lower():
# Agent lặp quá nhiều bước (thường do tra web mãi không xong) -> câu
# thân thiện thay vì lỗi thô, kèm gợi ý.
return ToolResult(True, "Câu này cần khá nhiều bước nên mình tạm dừng để tránh "
"chạy quá lâu. Bạn thử nói cụ thể hơn (ví dụ tên/số hiệu "
"văn bản), hoặc gửi lại giúp mình nhé.", {"kind": "chat"})
else:
return ToolResult(False, f"Lỗi khi xử lý: {e}", {"kind": "chat"})
# Fallback: model (llama) in tool-call ra dạng CHỮ thay vì gọi thật -> tự thực thi.
if not deps.routed:
parsed = _parse_text_call(text)
if parsed:
tname, arg = parsed
mod = tname[4:] if tname.startswith("run_") else ""
if mod in self.tools:
res2 = self._exec_module(mod, arg or message, deps)
text = res2.summary or text
elif tname in ("web_search", "fetch_url"):
text = self._text_web_fallback(tname, arg, message)
deps.searched = True
# LƯỚI AN TOÀN thời sự: câu hỏi tỉ số/kết quả/"hiện tại" mà agent trả lời kiểu
# chat (không chạy module). Kể cả khi model ĐÃ search, câu trả lời cuối của model
# yếu vẫn hay sai mốc thời gian/bịa -> ép tổng hợp lại từ web bằng prompt tập
# trung (có ngày hôm nay). Chốt chặn chống bịa, không phụ thuộc model ngoan hay không.
safety = False
if not deps.routed and _TIME_SENSITIVE_RE.search(message or ""):
if callable(emit):
emit({"type": "step", "kind": "running", "name": "Tra web (chống bịa)",
"machine": "web_search"})
grounded = self._text_web_fallback("web_search", message, message)
if callable(emit):
emit({"type": "step", "kind": "done", "name": "Tra web (chống bịa)",
"machine": "web_search", "status": "ok"})
if grounded:
text, safety, deps.searched = grounded, True, True
if not deps.routed and callable(emit):
emit({"type": "route", "tool": "web" if safety else "chat",
"reason": "tra web (chống bịa)" if safety else "trò chuyện / hỏi đáp"})
text = _TEXT_CALL_RE.sub("", text).strip() or text # dọn text-call còn sót
ok = not (deps.any_fail and not deps.any_ok)
data = dict(deps.last_data)
if reasoning:
data.setdefault("reasoning", reasoning)
data.setdefault("kind", deps.routed[0] if deps.routed else "chat")
data["usage"] = _usage.get()
return ToolResult(ok, text or "(không có nội dung trả lời)", data)
def _split_frontmatter(text: str) -> tuple[str, str]:
from ..modules.store import parse_frontmatter
meta, body = parse_frontmatter(text)
return "", body