code/src/agents/adaptive_rag.py

"""
LangGraph state machine for Agentic Adaptive RAG.

9 nodes orchestrated in a self-reflective loop with 2 retries.
Uses the LangGraph StateGraph API with typed state and conditional edges.

Architecture:
  START → memory_retrieve → route_query
    ├─ "direct" → generate_answer → self_reflect → memory_store → END
    └─ "search"/"kg"/"web" → rewrite_query → retrieve → grade_documents
         ├─ relevant → generate_answer → self_reflect → memory_store → END
         └─ irrelevant → rewrite_retry → rewrite_query (loop, max 2)

Self-reflection: hallucination check + completeness check → verdict pass/fail.
  FAIL → rewrite_retry → rewrite_query (loop, max 2)
  PASS → memory_store → END
"""

from __future__ import annotations

import json
import logging
from typing import Annotated, Any, Dict, List, Literal, Optional, TypedDict

from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
from langgraph.checkpoint.memory import MemorySaver

from langchain_core.messages import HumanMessage, AIMessage

from src.agents.agent_config import (
    AGENT_MAX_RETRIES, AGENT_SEARCH_TIMEOUT,
    AGENT_MAX_CONTEXT_TOKENS, AGENT_DEFAULT_K,
)
from src.agents.prompts import (
    ROUTE_SYSTEM_PROMPT, REWRITE_PROMPT, REWRITE_IRRELEVANT_PROMPT,
    REWRITE_HALLUCINATION_PROMPT, REWRITE_INCOMPLETE_PROMPT,
    GRADE_PROMPT, GRADE_BATCH_PROMPT, GENERATE_PROMPT, GENERATE_NO_CONTEXT,
    REFLECT_HALLUCINATION_PROMPT, REFLECT_COMPLETENESS_PROMPT,
    STRUCTURED_REWRITE_PROMPT, HYDE_PROMPT,
)
from src.agents.tracing import traced_llm_call

logger = logging.getLogger(__name__)


class RetrievedDoc(TypedDict, total=False):
    """Typed schema for a retrieved document. Filled incrementally by nodes."""
    id: str
    content: str
    score: float
    collection: str
    cve_ids: list[str]
    relevance_grade: str


class ReflectionResult(TypedDict, total=False):
    """Structured reflection output for routing decisions."""
    verdict: Literal["pass", "fail"]
    hallucination: bool
    completeness: bool
    hallucination_score: float
    completeness_score: float
    unsupported_claims: list[str]
    missing_aspects: list[str]


class RAGState(TypedDict):
    """Typed state for the agent graph (9 functional nodes)."""
    messages: Annotated[list, add_messages]
    original_query: str
    rewritten_query: str
    route_decision: str
    rewrite_reason: str
    rewrite_strategy: str
    search_collections: list[str]
    retrieved_docs: list[dict]
    kg_context: str
    kg_enriched: bool
    memory_context: str
    generation: str
    reflection: dict
    retry_count: int
    _relevant_count: int
    mem0_user_id: str
    tracing_trace_id: str
    kg_seeds: list[dict]
    hyde_doc: str
    filters: dict
    web_fallback_used: bool


def _parse_json_safely(text: str, default: dict = None) -> dict:
    """Robust JSON parser handling markdown code blocks, think-tags, and partial output."""
    if default is None:
        default = {}
    import re as _re
    text = (text or "").strip()
    # Strip DeepSeek/reasoning <think>...</think> blocks before any other processing
    text = _re.sub(r'<think>.*?</think>', '', text, flags=_re.DOTALL).strip()
    for prefix in ("```json", "```"):
        if text.startswith(prefix):
            text = text[len(prefix):]
    if text.endswith("```"):
        text = text[:-3]
    text = text.strip()
    try:
        return json.loads(text)
    except json.JSONDecodeError:
        try:
            match = _re.search(r'\{.*\}', text, _re.DOTALL)
            if match:
                return json.loads(match.group())
        except (json.JSONDecodeError, AttributeError):
            pass
        return default


def _extract_cve_ids(text: str) -> list[str]:
    """Extract CVE IDs from text."""
    import re
    return list(set(re.findall(r'CVE-\d{4}-\d{4,}', text, re.IGNORECASE)))


# ─────────────────────────────────────────────────────────────────────────────
# Node factories (runtime deps injected at compile time)
# ─────────────────────────────────────────────────────────────────────────────

def make_memory_retrieve(memory):
    """Pre-hook: recall past context from Mem0."""
    def memory_retrieve(state: RAGState) -> dict:
        query = state.get("original_query", "")
        user_id = state.get("mem0_user_id", "default_session")
        if memory is None or not query:
            return {"memory_context": ""}
        try:
            ctx = memory.recall(query, user_id)
            logger.info("Memory recall: %d chars", len(ctx))
            return {"memory_context": ctx}
        except Exception as e:
            logger.warning("Memory recall failed: %s", e)
            return {"memory_context": ""}
    return memory_retrieve


def make_route_query(llm_client):
    """Route node: classify user intent + decide which collections to search."""
    def route_query(state: RAGState) -> dict:
        query = state.get("original_query", "")
        if llm_client is None:
            return {"route_decision": "search", "search_collections": ["cve"]}
        try:
            trace_id = state.get("tracing_trace_id", "")
            with traced_llm_call(
                llm_client, ROUTE_SYSTEM_PROMPT + f"\n\nUser query: {query}",
                "route", trace_id=trace_id, max_tokens=200,
            ) as gen:
                response = gen()
            parsed = _parse_json_safely(response, {"intent": "search", "collections": ["cve"]})
            intent = parsed.get("intent", "search")
            collections = parsed.get("collections", ["cve"])
            if not isinstance(collections, list) or not collections:
                collections = ["cve"]
            logger.info("Route: intent=%s collections=%s", intent, collections)
            return {
                "route_decision": intent,
                "search_collections": collections,
                "rewrite_reason": "",
                "retry_count": state.get("retry_count", 0),
                "kg_enriched": False,
            }
        except Exception as e:
            logger.warning("Route failed: %s — defaulting to search/cve", e)
            return {
                "route_decision": "search", "search_collections": ["cve"],
                "rewrite_reason": "", "kg_enriched": False,
            }
    return route_query


def _pick_rewrite_prompt(reason: str, query: str) -> str:
    """Select the right rewrite prompt based on retry reason."""
    if reason == "irrelevant_docs":
        return REWRITE_IRRELEVANT_PROMPT.format(question=query)
    if reason == "hallucination":
        return REWRITE_HALLUCINATION_PROMPT.format(question=query)
    if reason == "incomplete":
        return REWRITE_INCOMPLETE_PROMPT.format(question=query)
    return REWRITE_PROMPT.format(question=query)


def _select_rewrite_strategy(reason: str, retry: int, route: str) -> str:
    """Choose rewrite strategy based on retry context."""
    if route == "investigate":
        return "hyde"
    if reason == "irrelevant_docs" and retry == 1:
        return "hyde"
    if reason == "irrelevant_docs":
        return "irrelevant"
    if reason == "hallucination":
        return "hallucination"
    if reason == "incomplete":
        return "incomplete"
    return "structured"


def make_rewrite_query(llm_client, cheat_sheet=None):
    """Rewrite node: reformulate query with cheat-sheet hints and strategy selection.

    Strategies:
      structured   — initial pass: JSON output {hyde_doc, search_query, kg_seeds, filters}
      hyde         — retry-1 or investigate route: hypothetical document embedding
      irrelevant   — retry-2 after irrelevant docs: broaden/rephrase
      hallucination / incomplete — reflection-driven rewrites
    """
    def rewrite_query(state: RAGState) -> dict:
        query   = state.get("original_query", "")
        reason  = state.get("rewrite_reason", "")
        retry   = state.get("retry_count", 0)
        route   = state.get("route_decision", "search")
        memctx  = state.get("memory_context", "") or "(none)"
        trace_id = state.get("tracing_trace_id", "")

        strategy = _select_rewrite_strategy(reason, retry, route)
        out: dict = {"rewrite_strategy": strategy}

        # Build cheat-sheet hint block
        hint_block = ""
        if cheat_sheet is not None:
            try:
                hints = cheat_sheet.entity_to_hints(query)
                hint_block = cheat_sheet.render_hint_block(hints) or ""
            except Exception as e:
                logger.debug("Cheat-sheet hint failed: %s", e)

        if llm_client is None:
            out["rewritten_query"] = query
            return out

        try:
            if strategy == "structured":
                prompt = STRUCTURED_REWRITE_PROMPT.format(
                    question=query,
                    memory_context=memctx,
                    cheat_sheet_hints=hint_block or "(none)",
                )
                with traced_llm_call(
                    llm_client, prompt, "rewrite_structured",
                    trace_id=trace_id,
                    system_prompt="Answer in JSON only.", max_tokens=400,
                ) as gen:
                    raw = gen()
                parsed = _parse_json_safely(raw, {})
                out["rewritten_query"] = parsed.get("search_query") or query
                out["hyde_doc"]        = parsed.get("hyde_doc") or ""
                out["kg_seeds"]        = [
                    s for s in parsed.get("kg_seeds", [])
                    if isinstance(s, dict) and "node_label" in s and "node_id" in s
                ]
                out["filters"]         = parsed.get("filters") or {}

            elif strategy == "hyde":
                prompt = HYDE_PROMPT.format(
                    question=query,
                    cheat_sheet_hints=hint_block or "(none)",
                )
                with traced_llm_call(
                    llm_client, prompt, "rewrite_hyde",
                    trace_id=trace_id, max_tokens=300,
                ) as gen:
                    hyde = gen().strip()
                out["hyde_doc"]        = hyde
                out["rewritten_query"] = hyde or query
                out["kg_seeds"]        = state.get("kg_seeds") or []

            else:
                template = {
                    "irrelevant":    REWRITE_IRRELEVANT_PROMPT,
                    "hallucination": REWRITE_HALLUCINATION_PROMPT,
                    "incomplete":    REWRITE_INCOMPLETE_PROMPT,
                }[strategy]
                with traced_llm_call(
                    llm_client, template.format(question=query),
                    f"rewrite_{strategy}",
                    trace_id=trace_id, max_tokens=200,
                ) as gen:
                    out["rewritten_query"] = gen().strip() or query

        except Exception as e:
            logger.warning("Rewrite[%s] failed: %s", strategy, e)
            out.setdefault("rewritten_query", query)

        logger.info(
            "Rewrite[%s] retry=%d → '%s' (seeds=%d, hyde=%d chars, hints=%d chars)",
            strategy, retry,
            out.get("rewritten_query", "")[:60],
            len(out.get("kg_seeds") or []),
            len(out.get("hyde_doc") or ""),
            len(hint_block),
        )
        return out
    return rewrite_query


def _parse_search_text(text: str) -> list[dict]:
    """Parse the formatted output of the search() tool back into doc dicts.

    The tool emits blocks: '[N] <id> (meta) score=X.XXX\\n<text>'
    Unrecognised formats are returned as a single raw doc.
    """
    import re
    docs = []
    for block in re.split(r"\n(?=\[\d+\])", text.strip()):
        m = re.match(r"\[(\d+)\]\s+(\S+).*?score=([\d.]+)\n(.+)", block, re.DOTALL)
        if m:
            doc_id = m.group(2)
            docs.append({
                "id":    doc_id,
                "text":  m.group(4).strip(),
                "score": float(m.group(3)),
                "metadata": {"cve_id": doc_id if doc_id.upper().startswith("CVE-") else ""},
            })
    if not docs and text.strip():
        docs.append({"id": "search-raw", "text": text.strip(), "score": 0.5, "metadata": {}})
    return docs


def _render_subgraph(sub: dict, seed_ids: list[str]) -> str:
    parts = [f"Knowledge Graph (seeds: {', '.join(seed_ids)}):"]
    for n in sub.get("nodes", [])[:15]:
        parts.append(f"  [{n.get('label','?')}] {n.get('id') or n.get('name') or '?'}")
    edge_types = sorted({e.get("type", "") for e in sub.get("edges", [])})
    if edge_types:
        parts.append(f"Relationships: {', '.join(edge_types)}")
    return "\n".join(parts)


_REACT_SYSTEM = (
    "You are a CVE evidence-gathering agent. Your job: collect the best context for "
    "the user query by calling tools strategically. Plan briefly then act.\n\n"
    "Heuristics:\n"
    "- ALWAYS call `search` first with the reformulated query and chosen collections.\n"
    "- If the query or pre-extracted seeds contain a CVE-ID → also call `explore_kg` "
    "  with node_label='CVE'.\n"
    "- If seeds contain a Product, CWE, Technique, Tactic, Vendor, or CAPEC ID → call "
    "  `explore_kg` with that node_label.\n"
    "- If the user describes a SYMPTOM or BEHAVIOR (no CVE/CWE/product) → call "
    "  `translate_symptom` FIRST, then use returned keywords for `search` and returned "
    "  techniques/CWEs for `explore_kg`.\n"
    "- For 'similar to CVE-X' queries → call `find_similar_cves`.\n"
    "- Do NOT call `search_web` — it is reserved for automatic fallback only.\n"
    "- Stop after at most 4 tool calls. Return a 1-sentence summary when done."
)


def make_retrieve(rag_system, graph_service, agent_tools=None, chat_model=None, cheat_sheet=None):
    """
    Retrieve node: ReAct tool-calling loop (primary) with hardcoded-pipeline fallback.

    When chat_model is available, uses LangGraph's create_react_agent with the
    agent_tools toolbelt (search, explore_kg, find_similar_cves, translate_symptom,
    search_web). Falls back to direct rag_system.search + KG auto-enrich if
    chat_model is None or if the ReAct agent raises.

    After the ReAct loop (or fallback), always runs post-loop KG auto-enrichment
    on CVE IDs surfaced in retrieved docs.
    """
    from langchain_core.messages import SystemMessage, HumanMessage, ToolMessage

    def _legacy_retrieve(state: RAGState) -> dict:
        """Original hardcoded pipeline — kept as fallback."""
        query = state.get("rewritten_query") or state.get("original_query", "")
        collections = state.get("search_collections", ["cve"])
        route = state.get("route_decision", "search")
        k = AGENT_DEFAULT_K

        retrieved_docs: list[dict] = []
        kg_context = ""
        kg_enriched = False

        if route != "direct":
            all_results: list[dict] = []
            for col in collections:
                try:
                    results = rag_system.search(query, n_results=k * 2, collection=col)
                    all_results.extend(results)
                except Exception as e:
                    logger.warning("Search failed for %s: %s", col, e)
            all_results.sort(key=lambda x: x.get("score", 0), reverse=True)
            seen = set()
            for r in all_results:
                rid = r.get("id", "")
                if rid not in seen:
                    seen.add(rid)
                    retrieved_docs.append(r)
            retrieved_docs = retrieved_docs[:k]

        if not retrieved_docs and route == "kg" and graph_service is not None:
            cve_ids = _extract_cve_ids(query)
            if cve_ids:
                try:
                    sub = graph_service.subgraph_from_nodes(
                        [{"label": "CVE", "id": cve_ids[0]}], hops=1
                    )
                    nodes = sub.get("nodes", [])
                    if nodes:
                        kg_context = _render_subgraph(sub, [cve_ids[0]])
                        kg_enriched = True
                        retrieved_docs.append({
                            "id": cve_ids[0], "text": kg_context,
                            "metadata": {"source": "neo4j_knowledge_graph"}, "score": 1.0,
                        })
                except Exception as e:
                    logger.warning("KG fallback failed: %s", e)

        # KG auto-enrich from top docs
        if graph_service is not None and retrieved_docs and not kg_context:
            cve_ids_found = [
                doc.get("metadata", {}).get("cve_id", "")
                for doc in retrieved_docs[:3]
                if doc.get("metadata", {}).get("cve_id")
            ]
            if cve_ids_found:
                try:
                    sub = graph_service.subgraph_from_nodes(
                        [{"label": "CVE", "id": cid} for cid in cve_ids_found], hops=1
                    )
                    if sub.get("nodes"):
                        kg_context = _render_subgraph(sub, cve_ids_found)
                        kg_enriched = True
                except Exception as e:
                    logger.warning("KG auto-enrich failed: %s", e)

        logger.info("Legacy retrieve: %d docs, kg_enriched=%s", len(retrieved_docs), kg_enriched)
        return {"retrieved_docs": retrieved_docs, "kg_context": kg_context, "kg_enriched": kg_enriched}

    def retrieve(state: RAGState) -> dict:
        route = state.get("route_decision", "search")
        if route == "direct":
            return {"retrieved_docs": [], "kg_context": "", "kg_enriched": False}

        if chat_model is None or not agent_tools:
            return _legacy_retrieve(state)

        query    = state.get("rewritten_query") or state.get("original_query", "")
        cols     = state.get("search_collections", ["cve"])
        seeds    = state.get("kg_seeds") or []
        filters  = state.get("filters") or {}

        hint_block = ""
        if cheat_sheet is not None:
            try:
                hd = cheat_sheet.entity_to_hints(state.get("original_query", ""))
                hint_block = cheat_sheet.render_hint_block(hd) or ""
            except Exception:
                pass

        user_msg = (
            f"Reformulated query: {query}\n"
            f"Collections: {cols}\n"
            f"Pre-extracted KG seeds: {seeds}\n"
            f"Payload filters: {filters}\n"
            f"Cheat-sheet hints: {hint_block or '(none)'}"
        )

        try:
            from langgraph.prebuilt import create_react_agent
            agent = create_react_agent(chat_model, tools=agent_tools)
            result = agent.invoke(
                {"messages": [SystemMessage(_REACT_SYSTEM), HumanMessage(user_msg)]},
                config={"recursion_limit": 12},
            )
        except Exception as e:
            logger.warning("ReAct retrieve failed: %s — falling back to legacy pipeline", e)
            return _legacy_retrieve(state)

        # ── Collect docs from ToolMessages ───────────────────────────────────
        retrieved_docs: list[dict] = []
        all_cve_ids: set[str] = set()

        for m in result.get("messages", []):
            if not isinstance(m, ToolMessage):
                continue
            text = str(m.content or "")
            all_cve_ids.update(_extract_cve_ids(text))

            tool_name = getattr(m, "name", "") or ""
            if tool_name == "search":
                retrieved_docs.extend(_parse_search_text(text))
            elif tool_name in ("explore_kg", "find_similar_cves"):
                if text.strip():
                    retrieved_docs.append({
                        "id":    f"kg-{len(retrieved_docs)}",
                        "text":  text,
                        "score": 0.6,
                        "metadata": {"source": "neo4j"},
                    })
            elif tool_name == "translate_symptom":
                pass   # symptoms result is used by LLM for next tool calls, not a doc
            elif tool_name == "search_web":
                if text.strip():
                    retrieved_docs.append({
                        "id":    f"web-{len(retrieved_docs)}",
                        "text":  text,
                        "score": 0.5,
                        "metadata": {"source": "tavily"},
                    })

        # ── Post-loop KG auto-enrichment ────────────────────────────────────
        kg_context  = ""
        kg_enriched = False
        if graph_service is not None and all_cve_ids:
            try:
                sub = graph_service.subgraph_from_nodes(
                    [{"label": "CVE", "id": cid} for cid in list(all_cve_ids)[:3]], hops=1
                )
                if sub.get("nodes"):
                    kg_context  = _render_subgraph(sub, list(all_cve_ids)[:3])
                    kg_enriched = True
            except Exception as e:
                logger.warning("Post-ReAct KG enrich failed: %s", e)

        retrieved_docs = retrieved_docs[:AGENT_DEFAULT_K]
        logger.info(
            "ReAct retrieve: %d docs, %d CVE IDs surfaced, kg_enriched=%s",
            len(retrieved_docs), len(all_cve_ids), kg_enriched,
        )
        return {"retrieved_docs": retrieved_docs, "kg_context": kg_context, "kg_enriched": kg_enriched}

    return retrieve


def make_web_fallback(web_search_tool=None):
    """Web fallback node: triggered at retry-max when all retrieval attempts returned 0 relevant docs."""
    def web_fallback(state: RAGState) -> dict:
        if web_search_tool is None:
            logger.info("Web fallback: no web tool configured, skipping")
            return {"web_fallback_used": False}

        query = state.get("rewritten_query") or state.get("original_query", "")
        try:
            text = web_search_tool.invoke({"query": query})
            text = str(text or "")
        except Exception as e:
            logger.warning("Web fallback invocation failed: %s", e)
            return {"web_fallback_used": False}

        existing = list(state.get("retrieved_docs") or [])
        existing.append({
            "id":    "web-fallback",
            "text":  text,
            "score": 0.5,
            "metadata": {"source": "tavily"},
        })
        logger.info("Web fallback engaged: +1 web doc (%d chars)", len(text))
        return {
            "retrieved_docs":  existing,
            "web_fallback_used": True,
            "_relevant_count": 1,   # force graph to proceed to generate_answer
        }
    return web_fallback


def make_grade_documents(llm_client, reranker=None):
    """
    Grader node: score retrieved docs for relevance and decide whether to retry.

    Backend priority:
      1. reranker  — Jina Reranker v3 (fast, no tokens, reorders docs best-first)
      2. llm       — single batched LLM call (fallback when reranker is None)
      3. pass-all  — when both are unavailable (llm_client is also None)
    """
    def grade_documents(state: RAGState) -> dict:
        docs = state.get("retrieved_docs", [])
        query = state.get("original_query", "")
        retry_count = state.get("retry_count", 0)

        if not docs:
            logger.info("Grade: no docs → irrelevant")
            return {"_relevant_count": 0, "retry_count": retry_count, "rewrite_reason": "irrelevant_docs"}

        # ── Reranker path ────────────────────────────────────────────────────
        if reranker is not None:
            try:
                scored_docs, relevant_count = reranker.grade(query, docs)
                return {
                    "_relevant_count": relevant_count,
                    "retrieved_docs": scored_docs,   # reranked: best docs first
                    "retry_count": retry_count,
                    "rewrite_reason": "irrelevant_docs" if relevant_count == 0 else "",
                }
            except Exception as e:
                logger.warning("Reranker failed → LLM fallback: %s", e)

        # ── LLM batch path ───────────────────────────────────────────────────
        if llm_client is None:
            return {"_relevant_count": max(1, len(docs)), "retry_count": retry_count, "rewrite_reason": ""}

        batch = docs[:8]
        snippets = [f"[{i + 1}] {d.get('text', '')[:500]}" for i, d in enumerate(batch)]
        prompt = GRADE_BATCH_PROMPT.format(
            question=query,
            numbered_docs="\n\n".join(snippets),
        )
        try:
            with traced_llm_call(
                llm_client, prompt, "grade_batch",
                trace_id=state.get("tracing_trace_id", ""),
                system_prompt="Answer in JSON only.", max_tokens=400,
            ) as gen:
                response = gen()
            parsed = _parse_json_safely(response, {"grades": []})
            relevant_count = sum(
                1 for g in parsed.get("grades", [])
                if g.get("binary_score", "no") == "yes"
            )
        except Exception as e:
            logger.warning("Batch grade failed, defaulting all relevant: %s", e)
            relevant_count = len(batch)

        logger.info("Grade (LLM): %d/%d relevant", relevant_count, len(batch))
        return {
            "_relevant_count": relevant_count,
            "retry_count": retry_count,
            "rewrite_reason": "irrelevant_docs" if relevant_count == 0 else "",
        }
    return grade_documents


def make_generate_answer(llm_client, llm_runnable=None):
    """Generator node: synthesize answer from docs + KG + memory.

    When llm_runnable is provided, streams tokens via BaseLLMRunnable so that
    astream_events(version="v2") captures on_chain_stream events per token.
    Falls back to llm_client.generate() (traced) when llm_runnable is None.
    """
    from langchain_core.runnables.config import RunnableConfig

    def generate_answer(state: RAGState, config: RunnableConfig = None) -> dict:
        query = state.get("original_query", "")
        docs = state.get("retrieved_docs", [])
        kg_context = state.get("kg_context", "")
        memory_context = state.get("memory_context", "")

        if llm_client is None and llm_runnable is None:
            top_cve = "N/A"
            if docs:
                top_cve = docs[0].get("metadata", {}).get("cve_id", "Unknown")
            return {
                "generation": f"Found {len(docs)} results. Top match: {top_cve}. LLM unavailable — raw search only.",
                "messages": [AIMessage(content=f"Found {len(docs)} results. Top match: {top_cve}. LLM unavailable — raw search only.")],
            }

        if docs:
            retrieved_text = "\n\n".join(
                f"[{i+1}] {d.get('metadata', {}).get('cve_id', d.get('id', ''))}\n{d.get('text', '')[:600]}"
                for i, d in enumerate(docs[:6])
            )
            prompt = GENERATE_PROMPT.format(
                memory_context=memory_context or "(no past context)",
                retrieved_context=retrieved_text,
                kg_context=kg_context or "(no graph context)",
                question=query,
            )
        else:
            prompt = GENERATE_NO_CONTEXT.format(
                memory_context=memory_context or "(no past context)",
                question=query,
            )

        try:
            if llm_runnable is not None:
                # Stream via Runnable — each yielded token fires an on_chain_stream
                # event that astream_events(version="v2") surfaces to the caller.
                generation = ""
                for token in llm_runnable.stream(prompt, config=config):
                    generation += token
            else:
                with traced_llm_call(llm_client, prompt, "generate",
                                     trace_id=state.get("tracing_trace_id", ""),
                                     max_tokens=800) as gen:
                    generation = gen()

            logger.info("Generation: %d chars", len(generation))
            return {"generation": generation, "messages": [AIMessage(content=generation)]}
        except Exception as e:
            logger.error("Generation failed: %s", e)
            return {
                "generation": f"Answer generation failed: {e}",
                "messages": [AIMessage(content=f"Answer generation failed: {e}")],
            }
    return generate_answer


def make_self_reflect(llm_client):
    """Reflection node: hallucination check + completeness check → verdict."""
    def self_reflect(state: RAGState) -> dict:
        generation = state.get("generation", "")
        docs = state.get("retrieved_docs", [])
        query = state.get("original_query", "")
        retry_count = state.get("retry_count", 0)

        reflection = {
            "verdict": "pass",
            "hallucination": True,
            "completeness": True,
            "hallucination_score": 1.0,
            "completeness_score": 1.0,
            "unsupported_claims": [],
            "missing_aspects": [],
        }

        if llm_client is None or not generation or not docs:
            return {"reflection": reflection, "retry_count": retry_count}

        context_text = "\n\n".join(d.get("text", "")[:400] for d in docs[:4])

        # ── Hallucination check ──
        try:
            h_prompt = REFLECT_HALLUCINATION_PROMPT.format(context=context_text, generation=generation)
            with traced_llm_call(
                llm_client, h_prompt, "reflect_hallucination",
                trace_id=state.get("tracing_trace_id", ""),
                system_prompt="Answer in JSON only.", max_tokens=600,
            ) as gen:
                h_response = gen()
            h_parsed = _parse_json_safely(h_response, {"is_grounded": "yes", "unsupported_claims": [], "score": 1.0})
            if not isinstance(h_parsed, dict):
                h_parsed = {"is_grounded": "yes", "unsupported_claims": [], "score": 1.0}
            grounded = h_parsed.get("is_grounded", "yes") == "yes"
            reflection["hallucination"] = grounded
            reflection["hallucination_score"] = h_parsed.get("score", 1.0 if grounded else 0.0)
            reflection["unsupported_claims"] = h_parsed.get("unsupported_claims", [])
            logger.info("Reflect hallucination: %s score=%.2f", "PASS" if grounded else "FAIL", reflection["hallucination_score"])
        except Exception as e:
            logger.warning("Hallucination check failed: %s", e)

        # ── Completeness check ──
        try:
            c_prompt = REFLECT_COMPLETENESS_PROMPT.format(question=query, generation=generation)
            with traced_llm_call(
                llm_client, c_prompt, "reflect_completeness",
                trace_id=state.get("tracing_trace_id", ""),
                system_prompt="Answer in JSON only.", max_tokens=400,
            ) as gen:
                c_response = gen()
            c_parsed = _parse_json_safely(c_response, {"is_complete": "yes", "missing_aspects": [], "score": 1.0})
            if not isinstance(c_parsed, dict):
                c_parsed = {"is_complete": "yes", "missing_aspects": [], "score": 1.0}
            complete = c_parsed.get("is_complete", "yes") == "yes"
            reflection["completeness"] = complete
            reflection["completeness_score"] = c_parsed.get("score", 1.0 if complete else 0.0)
            reflection["missing_aspects"] = c_parsed.get("missing_aspects", [])
            logger.info("Reflect completeness: %s score=%.2f", "PASS" if complete else "FAIL", reflection["completeness_score"])
        except Exception as e:
            logger.warning("Completeness check failed: %s", e)

        # ── Determine verdict and rewrite_reason ──
        overall_pass = reflection["hallucination"] and reflection["completeness"]
        reflection["verdict"] = "pass" if overall_pass else "fail"

        rewrite_reason = ""
        if not reflection["hallucination"]:
            rewrite_reason = "hallucination"
        elif not reflection["completeness"]:
            rewrite_reason = "incomplete"

        return {"reflection": reflection, "retry_count": retry_count, "rewrite_reason": rewrite_reason}
    return self_reflect


def make_memory_store(memory):
    """Post-hook: save interaction to Mem0 for future recall."""
    def memory_store(state: RAGState) -> dict:
        query = state.get("original_query", "")
        generation = state.get("generation", "")
        user_id = state.get("mem0_user_id", "default_session")
        if memory is not None and generation:
            try:
                memory.save(query, generation, user_id)
                logger.info("Memory stored for user=%s", user_id)
            except Exception as e:
                logger.warning("Memory store failed: %s", e)
        return {}
    return memory_store


# ─────────────────────────────────────────────────────────────────────────────
# Conditional edge logic
# ─────────────────────────────────────────────────────────────────────────────

def _route_after_classify(state: RAGState) -> Literal["rewrite_query", "generate_answer"]:
    if state.get("route_decision", "search") == "direct":
        return "generate_answer"
    return "rewrite_query"


def _route_after_grade(state: RAGState) -> Literal["generate_answer", "rewrite_query", "web_fallback"]:
    from src.agents.agent_config import WEB_SEARCH_ENABLED
    relevant = state.get("_relevant_count", 0)
    retry = state.get("retry_count", 0)
    if relevant > 0:
        return "generate_answer"
    if retry < AGENT_MAX_RETRIES:
        return "rewrite_query"
    if WEB_SEARCH_ENABLED and not state.get("web_fallback_used", False):
        return "web_fallback"
    return "generate_answer"


def _route_after_reflect(state: RAGState) -> Literal["memory_store", "rewrite_query"]:
    reflection = state.get("reflection", {})
    retry = state.get("retry_count", 0)
    if reflection.get("verdict", "pass") == "pass":
        return "memory_store"
    if retry < AGENT_MAX_RETRIES:
        return "rewrite_query"
    return "memory_store"


def _increment_retry(state: RAGState) -> dict:
    return {"retry_count": state.get("retry_count", 0) + 1}


# ─────────────────────────────────────────────────────────────────────────────
# Graph compilation
# ─────────────────────────────────────────────────────────────────────────────

def compile_agent_graph(
    llm_client: Any,
    rag_system: Any,
    graph_service: Any = None,
    memory: Any = None,
    llm_runnable: Any = None,
    reranker: Any = None,
    cheat_sheet: Any = None,
    agent_tools: list = None,
    chat_model: Any = None,
) -> StateGraph:
    """
    Build and compile the full agent graph (10 nodes).

    Nodes: memory_retrieve, route_query, rewrite_query, retrieve,
           grade_documents, web_fallback, generate_answer, self_reflect,
           memory_store, rewrite_retry (incrementer)

    Returns compiled LangGraph StateGraph ready for .stream() or .invoke().
    """
    # Extract search_web tool from agent_tools for the web_fallback node
    web_search_tool = next(
        (t for t in (agent_tools or []) if getattr(t, "name", "") == "search_web"),
        None,
    )

    workflow = StateGraph(RAGState)

    workflow.add_node("memory_retrieve", make_memory_retrieve(memory))
    workflow.add_node("route_query", make_route_query(llm_client))
    workflow.add_node("rewrite_query", make_rewrite_query(llm_client, cheat_sheet))
    workflow.add_node("rewrite_retry", _increment_retry)
    workflow.add_node("retrieve", make_retrieve(rag_system, graph_service, agent_tools, chat_model, cheat_sheet))
    workflow.add_node("grade_documents", make_grade_documents(llm_client, reranker))
    workflow.add_node("web_fallback", make_web_fallback(web_search_tool))
    workflow.add_node("generate_answer", make_generate_answer(llm_client, llm_runnable))
    workflow.add_node("self_reflect", make_self_reflect(llm_client))
    workflow.add_node("memory_store", make_memory_store(memory))

    workflow.add_edge(START, "memory_retrieve")
    workflow.add_edge("memory_retrieve", "route_query")

    workflow.add_conditional_edges(
        "route_query", _route_after_classify,
        {"rewrite_query": "rewrite_query", "generate_answer": "generate_answer"},
    )

    workflow.add_edge("rewrite_query", "retrieve")
    workflow.add_edge("retrieve", "grade_documents")

    workflow.add_conditional_edges(
        "grade_documents", _route_after_grade,
        {
            "generate_answer": "generate_answer",
            "rewrite_query":   "rewrite_retry",
            "web_fallback":    "web_fallback",
        },
    )

    workflow.add_edge("rewrite_retry", "rewrite_query")
    workflow.add_edge("web_fallback", "generate_answer")
    workflow.add_edge("generate_answer", "self_reflect")

    workflow.add_conditional_edges(
        "self_reflect", _route_after_reflect,
        {"memory_store": "memory_store", "rewrite_query": "rewrite_retry"},
    )

    workflow.add_edge("memory_store", END)

    checkpointer = MemorySaver()
    graph = workflow.compile(checkpointer=checkpointer)
    grading = f"reranker(backend={reranker.backend})" if reranker else "llm"
    react = "react" if (chat_model is not None and agent_tools) else "legacy"
    logger.info(
        "Agent graph compiled ✓  10 nodes  max_retries=%d  grading=%s  retrieve=%s",
        AGENT_MAX_RETRIES, grading, react,
    )
    return graph