revamp analysis of docs

agent_api.py

@@ -37,6 +37,7 @@ from agents.doc_assistant import DocAssistant
 from langchain_openai import ChatOpenAI
 from langchain_xai import ChatXAI
 from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_openrouter import ChatOpenRouter
 from mistralai import Mistral
 import logging
 import traceback
@@ -83,21 +84,20 @@ class LLMConfig:
                 "X-Cerebras-3rd-Party-Integration": "langgraph"
             }
         ))
-        
-        self.llm  = NormalizedLLM(ChatOpenAI(
-            model=os.getenv("OPENROUTER_MODEL"),
+        self.utils_llm = NormalizedLLM(ChatOpenRouter(
+            model=os.getenv("OPENROUTER_MAIN_MODEL"),
             api_key=os.getenv("OPENROUTER_API_KEY"),
             base_url=os.getenv("OPENROUTER_URL"),
+            extra_body={
+                "models": json.loads(os.getenv("OPENROUTER_MODELS", "[]"))
+            },
         ))
         self.llm  = NormalizedLLM(ChatGoogleGenerativeAI(
             model=os.getenv("GEMINI_TOOL_MODEL", "gemini-3-flash-preview"),
             api_key=os.getenv("GOOGLE_API_KEY"),
             thinking_level="medium"
         ))
-        # self.llm = NormalizedLLM(ChatXAI(
-        #     model=os.getenv("XAI_TOOL_MODEL"),
-        # ))
-
+        
         # logger.info("✅ LLMConfig initialized with NormalizedLLM wrapper:")
         # logger.info(f"   - OpenAI LLM: {os.getenv('LLM_MODEL', 'gpt-5-nano-2025-08-07')}")
         # logger.info(f"   - Gemini LLM: {os.getenv('GEMINI_TOOL_MODEL', 'gemini-3-flash-preview')} (for tool calling)")
@@ -154,7 +154,7 @@ class CyberLegalAPI:
         
         self.agent_client = CyberLegalAgent(llm=self.llm_config.slm, tools=tools.tools_for_client,tools_facade=tools.tools_for_client_facade)
         self.agent_lawyer = CyberLegalAgent(llm=self.llm_config.slm, tools=tools.tools_for_lawyer,tools_facade=tools.tools_for_lawyer_facade)
-        self.pdf_analyzer = PDFAnalyzerAgent(llm=self.llm_config.slm, mistral_client=mistral_client)
+        self.pdf_analyzer = PDFAnalyzerAgent(llm=self.llm_config.utils_llm, mistral_client=mistral_client)
         # Initialize doc_editor with tools
         self.doc_editor = DocumentEditorAgent(
             llm=self.llm_config.slm,
@@ -193,13 +193,13 @@ class CyberLegalAPI:
         elif node.type == "file" and node.analysis:
             analysis_parts = []
             if node.analysis.summary:
-                summary_preview = node.analysis.summary[:100] + "..." if len(node.analysis.summary) > 100 else node.analysis.summary
+                summary_preview = node.analysis.summary
                 analysis_parts.append(f"summary: {summary_preview}")
             if node.analysis.actors:
-                actors_preview = node.analysis.actors[:100] + "..." if len(node.analysis.actors) > 100 else node.analysis.actors
+                actors_preview = node.analysis.actors
                 analysis_parts.append(f"actors: {actors_preview}")
             if node.analysis.key_details:
-                details_preview = node.analysis.key_details[:100] + "..." if len(node.analysis.key_details) > 100 else node.analysis.key_details
+                details_preview = node.analysis.key_details 
                 analysis_parts.append(f"key_details: {details_preview}")
             
             analysis_text = " | ".join(analysis_parts) if analysis_parts else "No analysis available"

agent_states/actors_merger.py

@@ -0,0 +1,9 @@
+
+from typing import TypedDict, List, Dict, Any
+
+
+class ActorsMergerState(TypedDict):
+    new_extractions: List[Dict[str, Any]]
+    existing_actors: List[Dict[str, Any]]
+    messages: List[Any]
+    completed: bool

agent_states/pdf_analyzer_state.py

@@ -3,33 +3,26 @@
 State management for PDF Analysis Agent
 """
 
-from typing import TypedDict, Optional, List
-from langchain_core.messages import BaseMessage
+from typing import TypedDict, Optional
 
 
 class PDFAnalyzerState(TypedDict):
-    """
-    State definition for the PDF Analysis Agent workflow
-    """
     # Input
     pdf_path: str
-    pdf_content: Optional[str]
-    
-    # Extraction results
+
+    # Extraction
     extracted_text: Optional[str]
-    
-    # OCR tracking
-    needs_ocr: bool  # True if PDF is scanned/image-based
-    ocr_performed: bool  # True if OCR was used
-    ocr_method: Optional[str]  # "mistral" or None
-    
+
+    # OCR
+    needs_ocr: bool
+    ocr_performed: bool
+    ocr_method: Optional[str]
+
     # Analysis results
     summary: Optional[str]
     actors: Optional[str]
     key_details: Optional[str]
-    
-    intermediate_steps: List[BaseMessage]
-    
+
     # Metadata
     document_type: Optional[str]
-    processing_status: str  # "pending", "extracting", "analyzing", "complete"
+    error: Optional[str]

agents/actors_merger.py

@@ -0,0 +1,138 @@
+
+import json
+import logging
+from typing import TypedDict, List, Dict, Any
+from agent_states.actors_merger_state import ActorResolutionState
+from langgraph.graph import StateGraph, END
+from langchain_core.messages import HumanMessage, SystemMessage, ToolMessage
+from prompts.actors_merger import SYSTEM_PROMPT,ACTOR_MERGER_PROMPT
+from utils.tools import tools_for_actors_merger, tools_for_actors_merger_facade
+
+logger = logging.getLogger(__name__)
+
+
+class ActorsMergerAgent:
+    def __init__(self, llm):
+        self.llm = llm.bind_tools(tools_for_actors_merger_facade, tool_choice="any")
+        self.workflow = self._build_workflow()
+
+    def _build_workflow(self):
+        workflow = StateGraph(ActorResolutionState)
+        workflow.add_node("reason", self._reason)
+        workflow.add_node("run_tools", self._run_tools)
+
+        workflow.set_entry_point("reason")
+        workflow.add_edge("reason", "run_tools")
+
+        workflow.add_conditional_edges(
+            "run_tools",
+            self._should_continue,
+            {
+                "continue": "reason",
+                "done": END,
+            },
+        )
+
+        return workflow.compile()
+
+    def _should_continue(self, state: ActorResolutionState) -> str:
+        return "done" if state["completed"] else "continue"
+
+    async def _reason(self, state: ActorResolutionState) -> ActorResolutionState:
+        if not state["messages"]:
+            state["messages"] = [
+                SystemMessage(content=SYSTEM_PROMPT),
+                HumanMessage(
+                    content=f"""
+                {ACTOR_MERGER_PROMPT}
+
+                NEW_ACTORS:
+                {json.dumps(new_extractions, indent=2)}
+
+                EXISTING_ACTORS:
+                {json.dumps(existing_actors, indent=2)}
+                """
+                ),
+            ]
+
+        response = await self.llm.ainvoke(state["messages"])
+        state["messages"].append(response)
+        return state
+
+    async def _run_tools(self, state: ActorResolutionState) -> ActorResolutionState:
+        last_message = state["messages"][-1]
+        tool_calls = getattr(last_message, "tool_calls", []) or []
+
+        for tool_call in tool_calls:
+            name = tool_call["name"]
+            args = tool_call.get("args", {})
+
+            if name == "add_actors":
+                actors = args.get("actors", [])
+                state["existing_actors"].extend(actors)
+                result = {"ok": True, "added": len(actors)}
+
+            elif name == "modify_actors":
+                modifications = args.get("modifications", [])
+                updated = 0
+
+                for mod in modifications:
+                    target_name = mod.get("target_name")
+                    if not target_name:
+                        continue
+
+                    for actor in state["existing_actors"]:
+                        if actor.get("name") == target_name:
+                            if mod.get("name"):
+                                actor["name"] = mod["name"]
+
+                            if mod.get("aliases"):
+                                actor["aliases"] = list(dict.fromkeys(
+                                    (actor.get("aliases", []) or []) + (mod.get("aliases", []) or [])
+                                ))
+
+                            if mod.get("description"):
+                                actor["description"] = mod["description"]
+
+                            if mod.get("implication"):
+                                actor["implication"] = mod["implication"]
+
+                            updated += 1
+                            break
+
+                result = {"ok": True, "updated": updated}
+
+            elif name == "attempt_completion_actor_resolution":
+                state["completed"] = True
+                result = {"ok": True, "completed": True}
+
+            else:
+                result = {"ok": False, "error": f"Unknown tool: {name}"}
+
+            state["messages"].append(
+                ToolMessage(
+                    content=json.dumps(result, ensure_ascii=False),
+                    tool_call_id=tool_call["id"],
+                )
+            )
+
+        return state
+
+    async def resolve(
+        self,
+        new_extractions: List[Dict[str, Any]],
+        existing_actors: List[Dict[str, Any]]
+    ) -> Dict[str, Any]:
+        initial_state: ActorResolutionState = {
+            "new_extractions": new_extractions,
+            "existing_actors": existing_actors,
+            "messages": [],
+            "completed": False,
+        }
+
+        final_state = await self.workflow.ainvoke(initial_state)
+
+        return {
+            "existing_actors": final_state["existing_actors"],
+            "completed": final_state["completed"],
+        }

agents/pdf_analyzer.py

@@ -35,16 +35,37 @@ class PDFAnalyzerAgent:
         workflow.add_node("extract_key_details", self._extract_key_details)
         workflow.add_node("generate_summary", self._generate_summary)
         workflow.set_entry_point("detect_pdf_type")
-        workflow.add_conditional_edges("detect_pdf_type", self._should_use_ocr, {"ocr": "ocr_pdf", "extract": "extract_content"})
+        workflow.add_conditional_edges(
+            "detect_pdf_type",
+            self._should_use_ocr,
+            {"ocr": "ocr_pdf", "extract": "extract_content"}
+        )
+
         workflow.add_edge("ocr_pdf", "extract_actors")
+        workflow.add_edge("ocr_pdf", "extract_key_details")
+        workflow.add_edge("ocr_pdf", "generate_summary")
+
         workflow.add_edge("extract_content", "extract_actors")
-        workflow.add_edge("extract_actors", "extract_key_details")
-        workflow.add_edge("extract_key_details", "generate_summary")
+        workflow.add_edge("extract_content", "extract_key_details")
+        workflow.add_edge("extract_content", "generate_summary")
+
+        workflow.add_edge("extract_actors", END)
+        workflow.add_edge("extract_key_details", END)
         workflow.add_edge("generate_summary", END)
+
         return workflow.compile()
     
     def _should_use_ocr(self, state: PDFAnalyzerState) -> str:
         return "ocr" if state.get("needs_ocr", False) else "extract"
+
+    async def _run_prompt(self, extracted_text: str, task_prompt: str) -> str:
+        messages = [
+            SystemMessage(content=SYSTEM_PROMPT),
+            HumanMessage(content=f"Here is the legal document to analyze:\n\n{extracted_text}"),
+            HumanMessage(content=task_prompt),
+        ]
+        response = await self.llm.ainvoke(messages)
+        return response.content
     
     async def _detect_pdf_type(self, state: PDFAnalyzerState) -> PDFAnalyzerState:
         import os
@@ -71,7 +92,6 @@ class PDFAnalyzerAgent:
             state["document_type"] = "unknown"
             logger.warning(f"⚠️  Unknown file format: {file_ext}, will attempt OCR")
         
-        state["processing_status"] = "extracting"
         return state
     
     async def _ocr_pdf(self, state: PDFAnalyzerState) -> PDFAnalyzerState:
@@ -118,17 +138,14 @@ class PDFAnalyzerAgent:
             
         except Exception as e:
             logger.error(f"❌ OCR failed: {e}")
-            state["processing_status"] = "failed"
-            state["extracted_text"] = f"Error: OCR processing failed - {str(e)}"
+            state["error"] = str(e)
+            state["extracted_text"] = None
             return state
         
-        state["processing_status"] = "analyzing"
         return state
     
     async def _extract_content(self, state: PDFAnalyzerState) -> PDFAnalyzerState:
         """Extract text content from PDF file"""
-        state["processing_status"] = "extracting"
-        
         try:
             pdf_path = state["pdf_path"]
             logger.info(f"📄 Extracting content from PDF: {pdf_path}")
@@ -138,9 +155,8 @@ class PDFAnalyzerAgent:
                 num_pages = len(reader.pages)
                 for page_num in range(num_pages):
                     page = reader.pages[page_num]
-                    extracted_text += page.extract_text() + "\n\n"
+                    extracted_text += (page.extract_text() or "") + "\n\n"
             state["extracted_text"] = extracted_text
-            state["processing_status"] = "analyzing"
             logger.info(f"✅ Extracted {num_pages} pages from PDF")
         
         except Exception as e:
@@ -157,29 +173,16 @@ class PDFAnalyzerAgent:
         
         logger.info("👥 Extracting actors...")
         
-        # Build conversation history with system message and document content
-        intermediate_steps = state.get("intermediate_steps", [])
-        
-        # Add system message if not present
-        if not intermediate_steps:
-            intermediate_steps.append(SystemMessage(content=SYSTEM_PROMPT))
-            intermediate_steps.append(HumanMessage(content=f"Here is the legal document to analyze:\n\n{state['extracted_text']}"))
-        
-        # Add prompt to extract actors
-        intermediate_steps.append(HumanMessage(content=EXTRACT_ACTORS_PROMPT))
-        
-        response = await self.llm.ainvoke(intermediate_steps)
-        intermediate_steps.append(response)
-        state["actors"] = response.content
-        state["intermediate_steps"] = intermediate_steps
+        response_content = await self._run_prompt(state["extracted_text"], EXTRACT_ACTORS_PROMPT)
+        state["actors"] = response_content
         
         # Log detailed LLM response
         logger.info("=" * 80)
         logger.info("🤖 LLM RESPONSE (extract_actors)")
         logger.info("=" * 80)
-        logger.info(f"📊 Response length: {len(response.content)} characters")
+        logger.info(f"📊 Response length: {len(response_content)} characters")
         logger.info(f"📄 Content preview (first 300 chars):")
-        logger.info(response.content[:300] + ("..." if len(response.content) > 300 else ""))
+        logger.info(response_content[:300] + ("..." if len(response_content) > 300 else ""))
         logger.info("=" * 80)
         logger.info("✅ Actors extracted")
         
@@ -193,22 +196,16 @@ class PDFAnalyzerAgent:
         
         logger.info("🔑 Extracting key details...")
         
-        # Continue the conversation
-        intermediate_steps = state.get("intermediate_steps", [])
-        intermediate_steps.append(HumanMessage(content=EXTRACT_KEY_DETAILS_PROMPT))
-        
-        response = await self.llm.ainvoke(intermediate_steps)
-        intermediate_steps.append(response)
-        state["key_details"] = response.content
-        state["intermediate_steps"] = intermediate_steps
+        response_content = await self._run_prompt(state["extracted_text"], EXTRACT_KEY_DETAILS_PROMPT)
+        state["key_details"] = response_content
         
         # Log detailed LLM response
         logger.info("=" * 80)
         logger.info("🤖 LLM RESPONSE (extract_key_details)")
         logger.info("=" * 80)
-        logger.info(f"📊 Response length: {len(response.content)} characters")
+        logger.info(f"📊 Response length: {len(response_content)} characters")
         logger.info(f"📄 Content preview (first 300 chars):")
-        logger.info(response.content[:300] + ("..." if len(response.content) > 300 else ""))
+        logger.info(response_content[:300] + ("..." if len(response_content) > 300 else ""))
         logger.info("=" * 80)
         logger.info("✅ Key details extracted")
         
@@ -222,23 +219,16 @@ class PDFAnalyzerAgent:
         
         logger.info("📝 Generating document summary...")
         
-        # Continue the conversation
-        intermediate_steps = state.get("intermediate_steps", [])
-        intermediate_steps.append(HumanMessage(content=GENERATE_SUMMARY_PROMPT))
-        
-        response = await self.llm.ainvoke(intermediate_steps)
-        intermediate_steps.append(response)
-        state["summary"] = response.content
-        state["intermediate_steps"] = intermediate_steps
-        state["processing_status"] = "complete"
+        response_content = await self._run_prompt(state["extracted_text"], GENERATE_SUMMARY_PROMPT)
+        state["summary"] = response_content
         
         # Log detailed LLM response
         logger.info("=" * 80)
         logger.info("🤖 LLM RESPONSE (generate_summary)")
         logger.info("=" * 80)
-        logger.info(f"📊 Response length: {len(response.content)} characters")
+        logger.info(f"📊 Response length: {len(response_content)} characters")
         logger.info(f"📄 Content preview (first 300 chars):")
-        logger.info(response.content[:300] + ("..." if len(response.content) > 300 else ""))
+        logger.info(response_content[:300] + ("..." if len(response_content) > 300 else ""))
         logger.info("=" * 80)
         logger.info("✅ Summary generated")
         
@@ -260,29 +250,26 @@ class PDFAnalyzerAgent:
         
         initial_state: PDFAnalyzerState = {
             "pdf_path": pdf_path,
-            "pdf_content": None,
             "extracted_text": None,
             "summary": None,
             "actors": None,
             "key_details": None,
-            "document_type": "image" if file_ext in ['.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.webp'] else None,
-            "processing_status": "pending",
-            "intermediate_steps": [],
+            "document_type": None,
             "needs_ocr": False,
             "ocr_performed": False,
-            "ocr_method": None
+            "ocr_method": None,
+            "error": None,
         }
         
         logger.info(f"🚀 Starting PDF analysis for: {pdf_path}")
         final_state = await self.workflow.ainvoke(initial_state)
         
-        logger.info(f"✅ PDF analysis complete. Status: {final_state['processing_status']}")
+        logger.info(f"✅ PDF analysis complete.")
         
         return {
             "summary": final_state.get("summary"),
             "actors": final_state.get("actors"),
             "key_details": final_state.get("key_details"),
-            "processing_status": final_state.get("processing_status"),
             "ocr_used": final_state.get("ocr_performed", False),
             "ocr_method": final_state.get("ocr_method")
-        }
+        }

prompts/actors_merger.py

@@ -0,0 +1,72 @@
+
+
+SYSTEM_PROMPT = """You are an actor resolution agent.
+
+You receive:
+1. Newly extracted actors from a legal document
+2. Existing actors already known in the system
+
+Your goal is to integrate all newly extracted actors into the existing actor list.
+
+Each actor has:
+- name
+- aliases
+- description
+- implication
+
+You can use only these tools:
+- add_actors: create one or more new actors
+- modify_actors: update existing actors if a new extraction clearly refers to them
+- attempt_completion: call this only when all extracted actors have been handled
+
+Rules:
+- Prefer modifying an existing actor if the new actor clearly matches it
+- Prefer adding a new actor if there is uncertainty
+- Use name, aliases, description, and implication to decide
+- Do not leave any extracted actor untreated
+"""
+
+ACTOR_MERGER_PROMPT = """
+You are integrating newly extracted actors from a legal document into an existing actor registry.
+
+You are given:
+
+NEW_ACTORS:
+Actors extracted from the current document.
+
+EXISTING_ACTORS:
+Actors already known in the system.
+
+Your goal is to integrate the new actors into the existing registry.
+
+Rules:
+
+1. If a NEW_ACTOR clearly refers to an EXISTING_ACTOR:
+   - Use modify_actors
+   - Add missing information such as:
+     - new aliases
+     - additional description
+     - additional implications
+   - Do NOT duplicate the actor.
+
+2. If a NEW_ACTOR does NOT match any existing actor:
+   - Use add_actors to create a new actor entry.
+
+3. Matching should consider:
+   - similar names
+   - aliases
+   - descriptions
+   - contextual role in the document.
+
+4. Be conservative with merges.
+If you are unsure whether two actors are the same, create a new actor.
+
+5. Continue until ALL NEW_ACTORS have been handled.
+
+6. When every actor has been processed, call attempt_completion.
+
+Remember:
+- Never ignore a NEW_ACTOR.
+- Never duplicate actors unnecessarily.
+- Prefer enriching existing actors rather than recreating them.
+"""

prompts/doc_assistant.py

@@ -3,7 +3,7 @@
 System prompts for the doc creator router agent
 """
 
-ROUTER_SYSTEM_PROMPT = """You are a Document Router Agent that decides whether to respond to a user's question or modify their HTML document.
+ROUTER_SYSTEM_PROMPT = """You were created by Hexiagon labs. You are Hexiagon AI, a Document Assistant Agent that decides whether to respond to a user's question or modify their HTML document.
 
 ## CRITICAL RULES
 

requirements.txt

@@ -12,6 +12,7 @@ langchain>=0.1.0
 langchain-openai>=0.1.0
 langchain-community>=0.0.20
 langchain-google-genai>=1.0.0
+langchain-openrouter>=0.1.0
 mistralai>=1.0.0
 langchain-xai==1.2.2
 # FastAPI and server dependencies

utils/tools.py

@@ -1077,6 +1077,168 @@ async def _attempt_completion(message: str) -> Dict[str, Any]:
         "message": message
     }
 
+# ============ ACTOR RESOLUTION TOOLS ============
+
+@tool
+async def add_actors(actors: List[Dict[str, Any]]) -> str:
+    """
+    Add one or more new actors to the actor registry.
+
+    Each actor should contain:
+    - name
+    - aliases
+    - description
+    - implication
+
+    Use this tool when a newly extracted actor does not reasonably match
+    an existing actor and should be added as a new entry.
+    """
+    return
+
+
+@tool
+async def modify_actors(modifications: List[Dict[str, Any]]) -> str:
+    """
+    Modify one or more existing actors.
+
+    Each modification should usually contain:
+    - target_name: name of the existing actor to update
+    - optionally updated name
+    - aliases
+    - description
+    - implication
+
+    Use this tool when a newly extracted actor appears to refer to an
+    already existing actor and you want to enrich or update that actor.
+    """
+    return
+
+
+@tool
+async def attempt_completion_actor_resolution(message: str) -> Dict[str, Any]:
+    """
+    Signal that actor resolution is complete.
+
+    Call this only when all newly extracted actors have been handled,
+    either by adding them as new actors or modifying existing ones.
+
+    Args:
+        message: Short summary of what was resolved
+
+    Returns:
+        Dict with 'ok' and 'message'
+    """
+    logger.info(f"  ✅ attempt_completion_actor_resolution | {message}")
+    return {
+        "ok": True,
+        "message": message
+    }
+
+
+@tool
+async def _add_actors(
+    existing_actors: List[Dict[str, Any]],
+    actors: List[Dict[str, Any]]
+) -> Dict[str, Any]:
+    """
+    Real implementation for adding actors.
+
+    Args:
+        existing_actors: Current actor registry from state
+        actors: New actors to add
+
+    Returns:
+        Dict with updated actor list
+    """
+    try:
+        updated_actors = existing_actors.copy()
+        updated_actors.extend(actors)
+
+        logger.info(f"  ✅ add_actors | added:{len(actors)}")
+
+        return {
+            "ok": True,
+            "existing_actors": updated_actors,
+            "added": len(actors)
+        }
+    except Exception as e:
+        return {
+            "ok": False,
+            "error": f"Error adding actors: {str(e)}"
+        }
+
+
+@tool
+async def _modify_actors(
+    existing_actors: List[Dict[str, Any]],
+    modifications: List[Dict[str, Any]]
+) -> Dict[str, Any]:
+    """
+    Real implementation for modifying existing actors.
+
+    Matching is intentionally simple for MVP:
+    - match by target_name against actor['name']
+
+    Each modification may contain:
+    - target_name
+    - name
+    - aliases
+    - description
+    - implication
+    """
+    try:
+        updated_actors = [actor.copy() for actor in existing_actors]
+        updated_count = 0
+
+        for mod in modifications:
+            target_name = mod.get("target_name")
+            if not target_name:
+                continue
+
+            for actor in updated_actors:
+                if actor.get("name") == target_name:
+                    if mod.get("name"):
+                        actor["name"] = mod["name"]
+
+                    if mod.get("aliases"):
+                        existing_aliases = actor.get("aliases", []) or []
+                        new_aliases = mod.get("aliases", []) or []
+                        actor["aliases"] = list(dict.fromkeys(existing_aliases + new_aliases))
+
+                    if mod.get("description"):
+                        actor["description"] = mod["description"]
+
+                    if mod.get("implication"):
+                        actor["implication"] = mod["implication"]
+
+                    updated_count += 1
+                    break
+
+        logger.info(f"  ✅ modify_actors | updated:{updated_count}")
+
+        return {
+            "ok": True,
+            "existing_actors": updated_actors,
+            "updated": updated_count
+        }
+    except Exception as e:
+        return {
+            "ok": False,
+            "error": f"Error modifying actors: {str(e)}"
+        }
+
+
+@tool
+async def _attempt_completion_actor_resolution(message: str) -> Dict[str, Any]:
+    """
+    Real implementation for actor resolution completion.
+    """
+    logger.info(f"  ✅ attempt_completion_actor_resolution | {message}")
+    return {
+        "ok": True,
+        "message": message
+    }
+
 
 # Export tool sets for different user types
 tools_for_client_facade = [query_knowledge_graph, find_lawyers, message_lawyer, search_web]
@@ -1091,4 +1253,8 @@ tools_for_doc_assistant = [_query_knowledge_graph, _retrieve_lawyer_document, _e
 tools_for_doc_editor_facade = [replace_html, add_html, delete_html, view_current_document, attempt_completion]
 tools_for_doc_editor = [_replace_html, _add_html, _delete_html, _view_current_document, _attempt_completion]
 
+tools_for_actors_merger_facade = [add_actors,modify_actors,attempt_completion_actor_resolution]
+
+tools_for_actors_merger = [_add_actors,_modify_actors,_attempt_completion_actor_resolution]
+
 tools = tools_for_client