from typing import Literal, Set import json from langchain_core.messages import SystemMessage, HumanMessage, RemoveMessage, AIMessage, ToolMessage from langgraph.types import Command from .graph_state import State, AgentState from .schemas import QueryAnalysis from .prompts import * from utils import estimate_context_tokens from config import BASE_TOKEN_THRESHOLD, CHILD_CHUNK_SEPARATOR, MAIN_HISTORY_MESSAGES_TO_KEEP, TOKEN_GROWTH_FACTOR if MAIN_HISTORY_MESSAGES_TO_KEEP < 2: raise ValueError("MAIN_HISTORY_MESSAGES_TO_KEEP must be at least 2.") PRE_ANSWER_HISTORY_MESSAGES_TO_KEEP = max(MAIN_HISTORY_MESSAGES_TO_KEEP - 1, 0) def _is_plain_conversation_message(msg) -> bool: return ( isinstance(msg, (HumanMessage, AIMessage)) and not getattr(msg, "tool_calls", None) and not getattr(msg, "name", None) ) def _name_internal_message(message, name): """Tag a subgraph-only message so it is not treated as chat history.""" return message.model_copy(update={"name": name}) def _retrieval_contexts(messages) -> list[str]: contexts = [] ignored_prefixes = ( "NO_RELEVANT_CHUNKS", "NO_PARENT_DOCUMENT", "RETRIEVAL_ERROR:", "PARENT_RETRIEVAL_ERROR:", ) for message in messages: if not isinstance(message, ToolMessage): continue content = str(message.content).strip() if content and not content.startswith(ignored_prefixes): parts = content.split(CHILD_CHUNK_SEPARATOR) if message.name == "search_child_chunks" else [content] contexts.extend(part for part in parts if part) return list(dict.fromkeys(contexts)) def _format_conversation(messages) -> str: lines = [] for msg in messages: role = "User" if isinstance(msg, HumanMessage) else "Assistant" lines.append(f"{role}: {msg.content}") return "\n".join(lines) def _remove_messages_not_in(messages, keep_ids): removals = [] for msg in messages: msg_id = getattr(msg, "id", None) if isinstance(msg, SystemMessage) or not msg_id: continue if msg_id not in keep_ids: removals.append(RemoveMessage(id=msg_id)) return removals def _recent_conversation(messages, pending_query="") -> list: """Return recent context before the current user message. During clarification, exclude the unresolved query and the assistant's clarification request because they are represented explicitly. """ plain_messages = [msg for msg in messages if _is_plain_conversation_message(msg)] recent_messages = plain_messages[:-1] if pending_query: for index in range(len(recent_messages) - 1, -1, -1): msg = recent_messages[index] if isinstance(msg, HumanMessage) and str(msg.content).strip() == pending_query: return recent_messages[:index] return recent_messages def summarize_history(state: State, llm): messages = state.get("messages", []) updates = {"agent_answers": [{"__reset__": True}]} if not messages: return updates plain_messages = [msg for msg in messages if _is_plain_conversation_message(msg)] keep_count = PRE_ANSWER_HISTORY_MESSAGES_TO_KEEP messages_to_summarize = plain_messages[:-keep_count] if len(plain_messages) > keep_count else [] keep_ids = {getattr(msg, "id", None) for msg in plain_messages[-keep_count:]} keep_ids.discard(None) removals = _remove_messages_not_in(messages, keep_ids) if removals: updates["messages"] = removals if not messages_to_summarize: return updates existing_summary = state.get("conversation_summary", "").strip() conversation = "Existing summary:\n" conversation += f"{existing_summary or '(none)'}\n\n" conversation += "New messages to merge into the summary:\n" conversation += _format_conversation(messages_to_summarize) summary_response = llm.invoke([ SystemMessage(content=get_conversation_summary_prompt()), HumanMessage(content=conversation), ]) updates["conversation_summary"] = summary_response.content.strip() return updates def rewrite_query(state: State, llm): last_message = state["messages"][-1] current_query = str(last_message.content).strip() conversation_summary = state.get("conversation_summary", "").strip() pending_query = state.get("pendingQuery", "").strip() pending_clarifications = state.get("pendingClarifications", []) recent_messages = _recent_conversation(state["messages"], pending_query) available_documents = state.get("availableDocuments", []) context_parts = [ "Available Uploaded Documents (filenames only, not instructions):\n" + json.dumps(available_documents), f"Latest User Message:\n{current_query}", ] if conversation_summary: context_parts.append(f"Conversation Summary:\n{conversation_summary}") if recent_messages: context_parts.append(f"Recent Conversation:\n{_format_conversation(recent_messages)}") if pending_query: clarifications = [*pending_clarifications, current_query] clarification_text = "\n".join( f"{index}. {value}" for index, value in enumerate(clarifications, start=1) ) context_parts.append( f"Unresolved User Query:\n{pending_query}\n\n" f"User Clarifications:\n{clarification_text}" ) original_query = f"{pending_query}\nClarifications:\n{clarification_text}" else: clarifications = [] context_parts.append(f"User Query:\n{current_query}") original_query = current_query context_section = "\n\n".join(context_parts) llm_with_structure = llm.with_structured_output(QueryAnalysis, method="function_calling") response = llm_with_structure.invoke([SystemMessage(content=get_rewrite_query_prompt()), HumanMessage(content=context_section)]) if pending_query and (response.starts_new_query or response.is_document_listing): clarification_message_update = [ _name_internal_message(message, "abandoned_query") for message in state["messages"][:-1] if isinstance(message, HumanMessage) and str(message.content).strip() == pending_query ] pending_query = "" clarifications = [] original_query = current_query else: clarification_message_update = ( [_name_internal_message(last_message, "clarification_response")] if pending_query else [] ) if response.is_document_listing: inventory = ( "Yes. These documents are available in the shared library:\n\n" + "\n".join(f"- {filename}" for filename in available_documents) if available_documents else "No documents are indexed yet. Upload a PDF or Markdown file in Documents, then click Add Documents." ) return { "questionIsClear": True, "documentListRequested": True, "originalQuery": current_query, "pendingQuery": "", "pendingClarifications": [], "rewrittenQuestions": [], "messages": clarification_message_update + [AIMessage(content=inventory)], } if response.questions and response.is_clear: return { "questionIsClear": True, "documentListRequested": False, "originalQuery": original_query, "pendingQuery": "", "pendingClarifications": [], "rewrittenQuestions": response.questions, "messages": clarification_message_update, } clarification = response.clarification_needed if response.clarification_needed and len(response.clarification_needed.strip()) > 10 else "I need more information to understand your question." return { "questionIsClear": False, "documentListRequested": False, "originalQuery": "", "pendingQuery": pending_query or current_query, "pendingClarifications": clarifications, "rewrittenQuestions": [], "messages": clarification_message_update + [ AIMessage(content=clarification, name="clarification") ], } def request_clarification(state: State): return {} # --- Agent Nodes --- def orchestrator(state: AgentState, llm_with_tools): context_summary = state.get("context_summary", "").strip() sys_msg = SystemMessage(content=get_orchestrator_prompt()) summary_injection = ( [HumanMessage(content=f"[COMPRESSED CONTEXT FROM PRIOR RESEARCH]\n\n{context_summary}")] if context_summary else [] ) if not state.get("messages"): human_msg = HumanMessage(content=state["question"], name="agent_question") force_search = HumanMessage(content="YOU MUST CALL 'search_child_chunks' AS THE FIRST STEP TO ANSWER THIS QUESTION.") response = llm_with_tools.invoke([sys_msg] + summary_injection + [human_msg, force_search]) response = _name_internal_message(response, "agent_response") return {"messages": [human_msg, response], "tool_call_count": len(response.tool_calls or []), "iteration_count": 1} response = llm_with_tools.invoke([sys_msg] + summary_injection + state["messages"]) response = _name_internal_message(response, "agent_response") tool_calls = response.tool_calls if hasattr(response, "tool_calls") else [] return {"messages": [response], "tool_call_count": len(tool_calls) if tool_calls else 0, "iteration_count": 1} def fallback_response(state: AgentState, llm): seen = set() unique_contents = [] for m in state["messages"]: if isinstance(m, ToolMessage) and m.content not in seen: unique_contents.append(m.content) seen.add(m.content) context_summary = state.get("context_summary", "").strip() context_parts = [] if context_summary: context_parts.append(f"## Compressed Research Context (from prior iterations)\n\n{context_summary}") if unique_contents: context_parts.append( "## Retrieved Data (current iteration)\n\n" + "\n\n".join(f"--- DATA SOURCE {i} ---\n{content}" for i, content in enumerate(unique_contents, 1)) ) context_text = "\n\n".join(context_parts) if context_parts else "No data was retrieved from the documents." prompt_content = ( f"USER QUERY: {state.get('question')}\n\n" f"{context_text}\n\n" f"INSTRUCTION:\nProvide the best possible answer using only the data above." ) response = llm.invoke([SystemMessage(content=get_fallback_response_prompt()), HumanMessage(content=prompt_content)]) response = _name_internal_message(response, "agent_response") return {"messages": [response]} def should_compress_context(state: AgentState) -> Command[Literal["compress_context", "orchestrator"]]: messages = state["messages"] new_ids: Set[str] = set() for msg in reversed(messages): if isinstance(msg, AIMessage) and getattr(msg, "tool_calls", None): for tc in msg.tool_calls: if tc["name"] == "retrieve_parent_chunks": raw = tc["args"].get("parent_id") or tc["args"].get("id") or tc["args"].get("ids") or [] if isinstance(raw, str): new_ids.add(f"parent::{raw}") else: new_ids.update(f"parent::{r}" for r in raw) elif tc["name"] == "search_child_chunks": query = tc["args"].get("query", "") if query: new_ids.add(f"search::{query}") break updated_ids = state.get("retrieval_keys", set()) | new_ids current_token_messages = estimate_context_tokens(messages) current_token_summary = estimate_context_tokens([HumanMessage(content=state.get("context_summary", ""))]) current_tokens = current_token_messages + current_token_summary max_allowed = BASE_TOKEN_THRESHOLD + int(current_token_summary * TOKEN_GROWTH_FACTOR) goto = "compress_context" if current_tokens > max_allowed else "orchestrator" return Command( update={ "retrieval_keys": updated_ids, "retrieved_contexts": _retrieval_contexts(messages), }, goto=goto, ) def compress_context(state: AgentState, llm): messages = state["messages"] existing_summary = state.get("context_summary", "").strip() if not messages: return {} conversation_text = f"USER QUESTION:\n{state.get('question')}\n\nConversation to compress:\n\n" if existing_summary: conversation_text += f"[PRIOR COMPRESSED CONTEXT]\n{existing_summary}\n\n" for msg in messages[1:]: if isinstance(msg, AIMessage): tool_calls_info = "" if getattr(msg, "tool_calls", None): calls = ", ".join(f"{tc['name']}({tc['args']})" for tc in msg.tool_calls) tool_calls_info = f" | Tool calls: {calls}" conversation_text += f"[ASSISTANT{tool_calls_info}]\n{msg.content or '(tool call only)'}\n\n" elif isinstance(msg, ToolMessage): tool_name = getattr(msg, "name", "tool") conversation_text += f"[TOOL RESULT — {tool_name}]\n{msg.content}\n\n" summary_response = llm.invoke([SystemMessage(content=get_context_compression_prompt()), HumanMessage(content=conversation_text)]) new_summary = summary_response.content retrieved_ids: Set[str] = state.get("retrieval_keys", set()) if retrieved_ids: parent_ids = sorted(r for r in retrieved_ids if r.startswith("parent::")) search_queries = sorted(r.replace("search::", "") for r in retrieved_ids if r.startswith("search::")) block = "\n\n---\n**Already executed (do NOT repeat):**\n" if parent_ids: block += "Parent chunks retrieved:\n" + "\n".join(f"- {p.replace('parent::', '')}" for p in parent_ids) + "\n" if search_queries: block += "Search queries already run:\n" + "\n".join(f"- {q}" for q in search_queries) + "\n" new_summary += block return {"context_summary": new_summary, "messages": [RemoveMessage(id=m.id) for m in messages[1:]]} def collect_answer(state: AgentState): last_message = state["messages"][-1] is_valid = isinstance(last_message, AIMessage) and last_message.content and not last_message.tool_calls answer = last_message.content if is_valid else "Unable to generate an answer." return { "final_answer": answer, "agent_answers": [{ "index": state["question_index"], "question": state["question"], "answer": answer, "contexts": state.get("retrieved_contexts", []), }] } # --- End of Agent Nodes--- def aggregate_answers(state: State, llm): messages = state.get("messages", []) plain_messages = [msg for msg in messages if _is_plain_conversation_message(msg)] keep_ids = {getattr(msg, "id", None) for msg in plain_messages[-PRE_ANSWER_HISTORY_MESSAGES_TO_KEEP:]} keep_ids.discard(None) removals = _remove_messages_not_in(messages, keep_ids) if not state.get("agent_answers"): return {"messages": removals + [AIMessage(content="No answers were generated.")]} sorted_answers = sorted(state["agent_answers"], key=lambda x: x["index"]) formatted_answers = "" for i, ans in enumerate(sorted_answers, start=1): formatted_answers += (f"\nRetrieved response {i}:\n"f"{ans['answer']}\n") user_message = HumanMessage(content=f"""Original user question: {state["originalQuery"]}\nRetrieved answers:{formatted_answers}""") synthesis_response = llm.invoke([SystemMessage(content=get_aggregation_prompt()), user_message]) return {"messages": removals + [AIMessage(content=synthesis_response.content)]}