fix tools more tests bettter iteration count

subagents/doc_editor.py

@@ -12,8 +12,7 @@ from langchain_core.messages import SystemMessage, HumanMessage, AIMessage, Tool
 
 from agent_states.doc_editor_state import DocEditorState
 from utils.doc_editor_tools import (
-    replace_html, add_html, delete_html, inspect_document, attempt_completion,
-    _replace_html, _add_html, _delete_html, _inspect_document, _attempt_completion
+    replace_html, add_html, delete_html, inspect_document, attempt_completion
 )
 from prompts.doc_editor import get_doc_editor_system_prompt, get_summary_system_prompt
 
@@ -39,11 +38,9 @@ class DocumentEditorAgent:
             llm: Language model instance (ChatOpenAI or compatible)
         """
         self.llm = llm
-        # Real tools (with _ prefix for internal functions) - these are actually called
-        self.tools_real = [_replace_html, _add_html, _delete_html, _inspect_document, _attempt_completion]
-        # Facade tools (exposed to LLM without doc_text parameter)
-        self.tools_facade = [replace_html, add_html, delete_html, inspect_document, attempt_completion]
-        self.llm_with_tools = self.llm.bind_tools(self.tools_facade)
+        # All tools are LangChain tools with @tool decorator
+        self.tools = [replace_html, add_html, delete_html, inspect_document, attempt_completion]
+        self.llm_with_tools = self.llm.bind_tools(self.tools)
         self.workflow = self._build_workflow()
     
     def _build_workflow(self) -> StateGraph:
@@ -73,6 +70,14 @@ class DocumentEditorAgent:
         Returns:
             "continue" if agent made tool calls or if attempt_completion not yet called, "end" if complete
         """
+        # Check max iterations first - stop regardless of tool calls
+        iteration_count = state.get("iteration_count", 0)
+        max_iterations = state.get("max_iterations", 10)
+        
+        if iteration_count >= max_iterations:
+            logger.warning(f"⚠️ Max iterations ({max_iterations}) reached - ending workflow")
+            return "end"
+        
         intermediate_steps = state.get("intermediate_steps", [])
         if not intermediate_steps:
             return "continue"
@@ -96,8 +101,8 @@ class DocumentEditorAgent:
             logger.info("✅ attempt_completion already called - ending workflow")
             return "end"
         
-        # Agent didn't make tool calls but also didn't complete - this shouldn't happen
-        # Continue to force the agent to make a tool call
+        # Agent didn't make tool calls but also didn't complete
+        # Increment iteration count was already done in _agent_node, so just continue
         logger.warning("⚠️ Agent response without tool calls - forcing continue (should call attempt_completion)")
         return "continue"
     
@@ -165,6 +170,9 @@ class DocumentEditorAgent:
         # Call LLM
         response = await self.llm_with_tools.ainvoke(intermediate_steps)
         intermediate_steps.append(response)
+        
+        # Increment iteration count for this LLM call (regardless of tool calls)
+        state["iteration_count"] = iteration_count + 1
         state["intermediate_steps"] = intermediate_steps
         return state
     
@@ -176,24 +184,28 @@ class DocumentEditorAgent:
         if not (hasattr(last_message, 'tool_calls') and last_message.tool_calls):
             return state
         
-        state["iteration_count"] = state.get("iteration_count", 0) + 1
-        
         for tool_call in last_message.tool_calls:
             tool_name = tool_call['name']
             
-            # Get the real tool function (with _ prefix)
-            real_tool_func = next((t for t in self.tools_real if t.__name__ == "_" + tool_name), None)
+            # Get the tool function directly from self.tools
+            tool_func = next((t for t in self.tools if t.name == tool_name), None)
             
-            if real_tool_func:
+            if tool_func:
                 args = tool_call['args'].copy()
                 
-                # Inject doc_text for editing tools and inspect_document
-                if tool_name in ["replace_html", "add_html", "delete_html", "inspect_document"]:
+                # Inject doc_text for editing tools that need it
+                if tool_name in ["replace_html", "add_html", "delete_html"]:
                     args["doc_text"] = state["doc_text"]
                     logger.info(f"📝 Injecting doc_text ({len(state['doc_text'])}b) into {tool_name}")
                 
+                # Special handling for inspect_document - inject doc_text and return content
+                if tool_name == "inspect_document":
+                    args["doc_text"] = state["doc_text"]
+                    logger.info(f"🔍 Inspecting document ({len(state['doc_text'])}b)")
+                
                 try:
-                    result = await real_tool_func.ainvoke(args)
+                    # Call the LangChain tool with .ainvoke()
+                    result = await tool_func.ainvoke(args)
                     
                     # Update doc_text if tool was successful
                     if result.get("ok") and "doc_text" in result:

tests/test_doc_editor.py

@@ -1,11 +1,10 @@
 #!/usr/bin/env python3
 """
 Test script for the Document Editor Agent
-Demonstrates Cline-like document editing with TipTap JSON
+Demonstrates Cline-like document editing with HTML
 """
 
 import asyncio
-import json
 import os
 import sys
 from dotenv import load_dotenv
@@ -20,117 +19,52 @@ from langchain_openai import ChatOpenAI
 from subagents.doc_editor import DocumentEditorAgent
 
 
-# Example TipTap JSON document (from user's example)
-SAMPLE_CONTRACT = {
-  "type": "doc",
-  "content": [
-    {
-      "type": "heading",
-      "attrs": { "level": 1, "textAlign": "center" },
-      "content": [
-        { "type": "text", "text": "CONTRAT DE PRESTATION DE SERVICES" }
-      ]
-    },
-    {
-      "type": "heading",
-      "attrs": { "level": 2, "textAlign": "left" },
-      "content": [
-        { "type": "text", "text": "Article 1 - Objet" }
-      ]
-    },
-    {
-      "type": "paragraph",
-      "attrs": { "textAlign": "justify" },
-      "content": [
-        { "type": "text", "text": "Le présent contrat a pour objet de définir les conditions dans lesquelles " },
-        { "type": "text", "marks": [{ "type": "bold" }], "text": "la Société X" },
-        { "type": "text", "text": " (ci-après « le Prestataire ») s'engage à fournir des services à " },
-        { "type": "text", "marks": [{ "type": "bold" }], "text": "la Société Y" },
-        { "type": "text", "text": " (ci-après « le Client »)." }
-      ]
-    },
-    {
-      "type": "heading",
-      "attrs": { "level": 2, "textAlign": "left" },
-      "content": [
-        { "type": "text", "text": "Article 2 - Durée" }
-      ]
-    },
-    {
-      "type": "paragraph",
-      "attrs": { "textAlign": "justify" },
-      "content": [
-        { "type": "text", "text": "Le contrat prend effet le " },
-        { "type": "text", "marks": [{ "type": "italic" }], "text": "1er janvier 2026" },
-        { "type": "text", "text": " pour une durée de " },
-        { "type": "text", "marks": [{ "type": "underline" }], "text": "12 mois" },
-        { "type": "text", "text": "." }
-      ]
-    },
-    {
-      "type": "bulletList",
-      "content": [
-        {
-          "type": "listItem",
-          "content": [
-            {
-              "type": "paragraph",
-              "content": [
-                { "type": "text", "text": "Renouvellement tacite" }
-              ]
-            }
-          ]
-        },
-        {
-          "type": "listItem",
-          "content": [
-            {
-              "type": "paragraph",
-              "content": [
-                { "type": "text", "text": "Préavis de 3 mois" }
-              ]
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "type": "table",
-      "content": [
-        {
-          "type": "tableRow",
-          "content": [
-            {
-              "type": "tableHeader",
-              "content": [{ "type": "paragraph", "content": [{ "type": "text", "text": "Service" }] }]
-            },
-            {
-              "type": "tableHeader",
-              "content": [{ "type": "paragraph", "content": [{ "type": "text", "text": "Tarif" }] }]
-            }
-          ]
-        },
-        {
-          "type": "tableRow",
-          "content": [
-            {
-              "type": "tableCell",
-              "content": [{ "type": "paragraph", "content": [{ "type": "text", "text": "Consultation" }] }]
-            },
-            {
-              "type": "tableCell",
-              "content": [{ "type": "paragraph", "content": [{ "type": "text", "text": "200€/h" }] }]
-            }
-          ]
-        }
-      ]
-    }
-  ]
-}
+# Example HTML document - Service Contract
+SAMPLE_CONTRACT = """<!DOCTYPE html>
+<html>
+<head>
+    <title>Contrat de prestation de services</title>
+</head>
+<body>
+    <h1>CONTRAT DE PRESTATION DE SERVICES</h1>
+    
+    <h2>Article 1 - Objet</h2>
+    <p>Le présent contrat a pour objet de définir les conditions dans lesquelles <strong>la Société X</strong> (ci-après « le Prestataire ») s'engage à fournir des services à <strong>la Société Y</strong> (ci-après « le Client »).</p>
+    
+    <h2>Article 2 - Durée</h2>
+    <p>Le contrat prend effet le <em>1er janvier 2026</em> pour une durée de <u>12 mois</u>.</p>
+    
+    <ul>
+        <li>Renouvellement tacite</li>
+        <li>Préavis de 3 mois</li>
+    </ul>
+    
+    <h2>Article 3 - Tarification</h2>
+    <p>Les services sont facturés selon les conditions suivantes :</p>
+    <table>
+        <thead>
+            <tr>
+                <th>Service</th>
+                <th>Tarif</th>
+            </tr>
+        </thead>
+        <tbody>
+            <tr>
+                <td>Consultation</td>
+                <td>200€/heure</td>
+            </tr>
+            <tr>
+                <td>Audit</td>
+                <td>500€/jour</td>
+            </tr>
+        </tbody>
+    </table>
+</body>
+</html>"""
 
 
 async def test_document_editor():
-    """Test the document editor agent with sample contract."""
+    """Test document editor agent with sample contract."""
     
     # Initialize LLM (requires OPENAI_API_KEY environment variable)
     api_key = os.getenv("OPENAI_API_KEY") or os.getenv("CEREBRAS_API_KEY")
@@ -148,13 +82,10 @@ async def test_document_editor():
     # Initialize document editor agent
     doc_editor = DocumentEditorAgent(llm=llm)
     
-    # Convert document to canonical format
-    canonical_doc = json.dumps(SAMPLE_CONTRACT, ensure_ascii=False, sort_keys=True, indent=2)
-    
     print("=" * 80)
-    print("📄 ORIGINAL DOCUMENT (TipTap JSON)")
+    print("📄 ORIGINAL DOCUMENT (HTML)")
     print("=" * 80)
-    print(canonical_doc)
+    print(SAMPLE_CONTRACT)
     print("\n")
     
     # Test 1: Simple text replacement
@@ -163,8 +94,8 @@ async def test_document_editor():
     print("=" * 80)
     
     result1 = await doc_editor.edit_document(
-        doc_text=canonical_doc,
-        user_instruction="Change the contract duration from 12 months to 24 months",
+        doc_text=SAMPLE_CONTRACT,
+        user_instruction="Change the contract duration from 12 months to 24 months in Article 2",
         doc_summaries=["Service contract between Company X and Company Y"],
         max_iterations=5
     )
@@ -177,16 +108,18 @@ async def test_document_editor():
         print("\n📄 MODIFIED DOCUMENT:")
         print(result1['doc_text'])
         
-        # Update canonical_doc for next test
-        canonical_doc = result1['doc_text']
+        # Update for next test
+        current_doc = result1['doc_text']
+    else:
+        current_doc = SAMPLE_CONTRACT
     
     print("\n" + "=" * 80)
-    print("🔧 TEST 2: Add Article 3 about pricing")
+    print("🔧 TEST 2: Add Article 4 about confidentiality")
     print("=" * 80)
     
     result2 = await doc_editor.edit_document(
-        doc_text=canonical_doc,
-        user_instruction="Add a new Article 3 after Article 2 that covers pricing with a heading 'Article 3 - Prix' and a paragraph explaining that services are billed at 200€ per hour",
+        doc_text=current_doc,
+        user_instruction="Add a new Article 4 after Article 3 that covers confidentiality with a heading 'Article 4 - Confidentialité' and a paragraph explaining that all information exchanged remains confidential",
         doc_summaries=["Service contract between Company X and Company Y"],
         max_iterations=8
     )
@@ -205,53 +138,76 @@ async def test_document_editor():
 
 
 async def test_tools_directly():
-    """Test the document editor tools directly without the agent."""
-    from utils.doc_editor_tools import replace, add, delete, attempt_completion, _canon
+    """Test document editor tools directly without the agent."""
+    from utils.doc_editor_tools import replace_html, add_html, delete_html, inspect_document, attempt_completion
     
     print("=" * 80)
     print("🔧 TESTING TOOLS DIRECTLY")
     print("=" * 80)
     
-    # Convert to canonical format
-    canonical_doc = json.dumps(SAMPLE_CONTRACT, ensure_ascii=False, sort_keys=True, indent=2)
+    current_doc = SAMPLE_CONTRACT
     
-    # Test replace
-    print("\n1️⃣ Testing 'replace' tool...")
-    result = await replace.ainvoke({
-        "doc_text": canonical_doc,
-        "search": '"text": "12 mois"',
-        "replace": '"text": "24 mois"',
+    # Test 1: replace_html
+    print("\n1️⃣ Testing 'replace_html' tool...")
+    result = await replace_html.ainvoke({
+        "doc_text": current_doc,
+        "search": "<u>12 mois</u>",
+        "replace": "<u>24 mois</u>",
         "expected_matches": 1
     })
     
     if result['ok']:
         print(f"✅ Replace successful! Found {result['matches']} matches")
-        canonical_doc = result['doc_text']
+        current_doc = result['doc_text']
     else:
         print(f"❌ Replace failed: {result['error']}")
     
-    # Test delete - simple text delete
-    print("\n2️⃣ Testing 'delete' tool (simple text deletion)...")
-    result = await delete.ainvoke({
-        "doc_text": canonical_doc,
-        "search": '"text": "Renouvellement tacite"',
+    # Test 2: add_html
+    print("\n2️⃣ Testing 'add_html' tool...")
+    result = await add_html.ainvoke({
+        "doc_text": current_doc,
+        "anchor_search": "<h2>Article 1 - Objet</h2>",
+        "insert": "<p><strong>Article ajouté : </strong>Ceci est un nouveau paragraphe inséré avant Article 1.</p>",
+        "position": "before",
         "expected_matches": 1
     })
     
     if result['ok']:
-        print(f"✅ Delete successful! Removed {result['matches']} text node")
-        canonical_doc = result['doc_text']
+        print(f"✅ Add successful! Inserted before anchor")
+        current_doc = result['doc_text']
+    else:
+        print(f"❌ Add failed: {result['error']}")
+    
+    # Test 3: delete_html
+    print("\n3️⃣ Testing 'delete_html' tool...")
+    result = await delete_html.ainvoke({
+        "doc_text": current_doc,
+        "search": "<li>Renouvellement tacite</li>",
+        "expected_matches": 1
+    })
+    
+    if result['ok']:
+        print(f"✅ Delete successful! Removed {result['matches']} element")
+        current_doc = result['doc_text']
     else:
         print(f"❌ Delete failed: {result['error']}")
-        print("   Note: Delete works best for simple text nodes. Complex structures may need careful matching.")
     
-    print("\n3️⃣ Final document after tool tests:")
-    print(canonical_doc)
+    print("\n4️⃣ Testing 'inspect_document' tool...")
+    # Note: In direct testing, we can pass doc_text for backward compatibility
+    # But in agent mode, it will be called without arguments
+    result = await inspect_document.ainvoke({"doc_text": current_doc})
+    if result['ok']:
+        print(f"✅ inspect_document works! Document size: {len(result['content'])} bytes")
+    else:
+        print(f"❌ inspect_document failed")
+    
+    print("\n5️⃣ Final document after tool tests:")
+    print(current_doc)
     
-    # Test attempt_completion
-    print("\n4️⃣ Testing 'attempt_completion' tool...")
+    # Test 6: attempt_completion
+    print("\n6️⃣ Testing 'attempt_completion' tool...")
     result = await attempt_completion.ainvoke({
-        "message": "Successfully modified the document"
+        "message": "Successfully modified the HTML document"
     })
     print(f"✅ Completion: {result}")
 

tests/test_tools_ainvoke.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""
+Simple test to verify tools work with .ainvoke()
+"""
+
+import asyncio
+import sys
+import os
+
+# Add parent directory to path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from utils.doc_editor_tools import replace_html, add_html, delete_html, inspect_document, attempt_completion
+
+
+async def test_tool_ainvoke():
+    """Test that all tools work with .ainvoke() method."""
+    
+    print("=" * 80)
+    print("Testing LangChain Tools with .ainvoke()")
+    print("=" * 80)
+    
+    # Simple HTML document for testing
+    doc_html = """
+    <html>
+        <head><title>Test</title></head>
+        <body>
+            <h1>Hello World</h1>
+            <p>This is a test paragraph.</p>
+        </body>
+    </html>
+    """
+    
+    # Test 1: replace_html
+    print("\n1️⃣ Testing replace_html.ainvoke()...")
+    try:
+        result = await replace_html.ainvoke({
+            "doc_text": doc_html,
+            "search": "Hello World",
+            "replace": "Bonjour Monde",
+            "expected_matches": 1
+        })
+        if result['ok']:
+            print(f"✅ replace_html works! Found {result['matches']} matches")
+            doc_html = result['doc_text']
+        else:
+            print(f"❌ replace_html failed: {result['error']}")
+            return False
+    except Exception as e:
+        print(f"❌ replace_html error: {e}")
+        return False
+    
+    # Test 2: add_html
+    print("\n2️⃣ Testing add_html.ainvoke()...")
+    try:
+        result = await add_html.ainvoke({
+            "doc_text": doc_html,
+            "anchor_search": "<h1>Bonjour Monde</h1>",
+            "insert": "<p>Added paragraph</p>",
+            "position": "after",
+            "expected_matches": 1
+        })
+        if result['ok']:
+            print(f"✅ add_html works! Found {result['matches']} matches")
+            doc_html = result['doc_text']
+        else:
+            print(f"❌ add_html failed: {result['error']}")
+            return False
+    except Exception as e:
+        print(f"❌ add_html error: {e}")
+        return False
+    
+    # Test 3: delete_html
+    print("\n3️⃣ Testing delete_html.ainvoke()...")
+    try:
+        result = await delete_html.ainvoke({
+            "doc_text": doc_html,
+            "search": "<p>This is a test paragraph.</p>",
+            "expected_matches": 1
+        })
+        if result['ok']:
+            print(f"✅ delete_html works! Removed {result['matches']} elements")
+            doc_html = result['doc_text']
+        else:
+            print(f"❌ delete_html failed: {result['error']}")
+            return False
+    except Exception as e:
+        print(f"❌ delete_html error: {e}")
+        return False
+    
+    # Test 4: inspect_document
+    print("\n4️⃣ Testing inspect_document.ainvoke()...")
+    try:
+        result = await inspect_document.ainvoke({
+            "doc_text": doc_html
+        })
+        if result['ok']:
+            print(f"✅ inspect_document works! Document size: {len(result['content'])} bytes")
+        else:
+            print(f"❌ inspect_document failed")
+            return False
+    except Exception as e:
+        print(f"❌ inspect_document error: {e}")
+        return False
+    
+    # Test 5: attempt_completion
+    print("\n5️⃣ Testing attempt_completion.ainvoke()...")
+    try:
+        result = await attempt_completion.ainvoke({
+            "message": "Successfully tested all tools"
+        })
+        if result['ok']:
+            print(f"✅ attempt_completion works! Message: {result['message']}")
+        else:
+            print(f"❌ attempt_completion failed")
+            return False
+    except Exception as e:
+        print(f"❌ attempt_completion error: {e}")
+        return False
+    
+    print("\n" + "=" * 80)
+    print("✅ ALL TESTS PASSED!")
+    print("=" * 80)
+    return True
+
+
+if __name__ == "__main__":
+    success = asyncio.run(test_tool_ainvoke())
+    sys.exit(0 if success else 1)

utils/doc_editor_tools.py

@@ -53,9 +53,10 @@ async def _validate_html(html: str) -> tuple[bool, str]:
         return False, f"HTML parsing failed: {str(e)}"
 
 
-async def _replace_html(doc_text: str, search: str, replace: str, expected_matches: int = 1) -> Dict[str, Any]:
+@tool
+async def replace_html(doc_text: str, search: str, replace: str, expected_matches: int = 1) -> Dict[str, Any]:
     """
-    Internal implementation of replace_html (with doc_text parameter).
+    Replace an exact block of HTML text in the document.
     
     This tool performs exact string matching on the HTML content.
     It's critical that the 'search' parameter matches exactly (including whitespace, tags, and attributes).
@@ -69,8 +70,12 @@ async def _replace_html(doc_text: str, search: str, replace: str, expected_match
     Returns:
         Dict with 'ok' (bool), 'doc_text' (updated HTML), 'matches' (int),
         and optionally 'error' (str) if something went wrong
+    
+    Example:
+        search = "<p>12 mois</p>"
+        replace = "<p>24 mois</p>"
     """
-    logger.info(f"  🔧 replace_html | search:{search}b | replace:{replace}b | expect:{expected_matches}")
+    logger.info(f"  🔧 replace_html | search:{len(search)}b | replace:{len(replace)}b | expect:{expected_matches}")
     
     # Count exact matches
     m = doc_text.count(search) if search else 0
@@ -107,11 +112,12 @@ async def _replace_html(doc_text: str, search: str, replace: str, expected_match
     }
 
 
-async def _add_html(doc_text: str, anchor_search: str, insert: str,
-                          position: Literal["before", "after"] = "after", 
-                          expected_matches: int = 1) -> Dict[str, Any]:
+@tool
+async def add_html(doc_text: str, anchor_search: str, insert: str,
+                   position: Literal["before", "after"] = "after", 
+                   expected_matches: int = 1) -> Dict[str, Any]:
     """
-    Internal implementation of add_html (with doc_text parameter).
+    Add HTML content before or after an anchor block in the document.
     
     This tool finds an exact anchor block and inserts new content adjacent to it.
     Useful for adding new paragraphs, sections, or elements.
@@ -126,8 +132,13 @@ async def _add_html(doc_text: str, anchor_search: str, insert: str,
     Returns:
         Dict with 'ok' (bool), 'doc_text' (updated HTML), 'matches' (int),
         and optionally 'error' (str) if something went wrong
+    
+    Example:
+        anchor_search = "<h2>Article 2 - Durée</h2>"
+        insert = "<h3>Article 3 - Prix</h3>"
+        position = "after"
     """
-    logger.info(f"  🔧 add_html | anchor:{anchor_search} | insert:{insert} | pos:{position} | expect:{expected_matches}")
+    logger.info(f"  🔧 add_html | anchor:{len(anchor_search)}b | insert:{len(insert)}b | pos:{position} | expect:{expected_matches}")
     
     # Count exact matches of anchor
     m = doc_text.count(anchor_search) if anchor_search else 0
@@ -167,9 +178,10 @@ async def _add_html(doc_text: str, anchor_search: str, insert: str,
     }
 
 
-async def _delete_html(doc_text: str, search: str, expected_matches: int = 1) -> Dict[str, Any]:
+@tool
+async def delete_html(doc_text: str, search: str, expected_matches: int = 1) -> Dict[str, Any]:
     """
-    Internal implementation of delete_html (with doc_text parameter).
+    Delete an exact block of HTML from document.
     
     This is a convenience wrapper around replace_html with an empty replacement.
     Useful for removing unwanted sections, clauses, or content.
@@ -182,122 +194,49 @@ async def _delete_html(doc_text: str, search: str, expected_matches: int = 1) ->
     Returns:
         Dict with 'ok' (bool), 'doc_text' (updated HTML), 'matches' (int),
         and optionally 'error' (str) if something went wrong
-    """
-    logger.info(f"  🔧 delete_html | search:{search} | expect:{expected_matches}")
-    return await _replace_html(doc_text, search, "", expected_matches)
-
-
-async def _inspect_document(doc_text: str) -> Dict[str, Any]:
-    """
-    Internal implementation of inspect_document (with doc_text parameter).
     
-    Returns the current document state for inspection.
+    Example:
+        search = "<p>This paragraph should be deleted</p>"
+    """
+    logger.info(f"  🔧 delete_html | search:{len(search)}b | expect:{expected_matches}")
     
-    Args:
-        doc_text: The HTML document content
+    # Count exact matches
+    m = doc_text.count(search) if search else 0
     
-    Returns:
-        Dict with 'ok' (bool) and 'content' (str)
-    """
-    logger.info(f"  🔍 inspect_document | size:{len(doc_text)}b")
-    return {
-        "ok": True,
-        "content": doc_text
-    }
-
-
-async def _attempt_completion(message: str) -> Dict[str, Any]:
-    """
-    Internal implementation of attempt_completion.
+    if m != expected_matches:
+        error = f"Search not found. Expected {expected_matches}, found {m}"
+        logger.warning(f"  ❌ {error}")
+        return {
+            "ok": False,
+            "error": error,
+            "matches": m,
+            "DANGER_PANEL": f"⚠️⚠️⚠️ MODIFICATION FAILED ⚠️⚠️⚠️\n{error}\nHTML must match EXACTLY and your search pattern has unexpected number of matches"
+        }
     
-    Signals that document editing is complete.
+    # Perform replacement with empty string
+    new_text = doc_text.replace(search, "", expected_matches)
     
-    Args:
-        message: Summary message describing what was changed
+    # Validate result with BeautifulSoup
+    is_valid, validation_error = await _validate_html(new_text)
+    if not is_valid:
+        logger.warning(f"  ❌ Validation failed: {validation_error}")
+        return {
+            "ok": False,
+            "error": f"Invalid HTML: {validation_error}",
+            "matches": m,
+            "DANGER_PANEL": f"⚠️⚠️⚠️ MODIFICATION FAILED ⚠️⚠️⚠️\n{validation_error}"
+        }
     
-    Returns:
-        Dict with 'ok' (bool) and 'message' (str)
-    """
-    logger.info(f"  ✅ attempt_completion | {message}")
+    logger.info(f"  ✅ Success | -{len(doc_text)-len(new_text)}b")
     return {
         "ok": True,
-        "message": message
+        "doc_text": new_text,
+        "matches": m
     }
 
 
 @tool
-async def replace_html(search: str, replace: str, expected_matches: int = 1) -> Dict[str, Any]:
-    """
-    Replace an exact block of HTML text in the document.
-    
-    This tool performs exact string matching on the HTML content.
-    It's critical that the 'search' parameter matches exactly (including whitespace, tags, and attributes).
-    
-    Args:
-        search: The exact HTML block to replace (must match exactly, including whitespace)
-        replace: The exact HTML block to insert
-        expected_matches: Expected number of occurrences (default: 1)
-    
-    Returns:
-        Dict with 'ok' (bool), 'doc_text' (updated HTML), 'matches' (int),
-        and optionally 'error' (str) if something went wrong
-    
-    Example:
-        search = "<p>12 mois</p>"
-        replace = "<p>24 mois</p>"
-    """
-
-
-@tool
-async def add_html(anchor_search: str, insert: str,
-                   position: Literal["before", "after"] = "after", 
-                   expected_matches: int = 1) -> Dict[str, Any]:
-    """
-    Add HTML content before or after an anchor block in the document.
-    
-    This tool finds an exact anchor block and inserts new content adjacent to it.
-    Useful for adding new paragraphs, sections, or elements.
-    
-    Args:
-        anchor_search: The exact HTML block to find (must match exactly)
-        insert: The exact HTML block to insert
-        position: "before" or "after" (default: "after")
-        expected_matches: Expected number of anchor occurrences (default: 1)
-    
-    Returns:
-        Dict with 'ok' (bool), 'doc_text' (updated HTML), 'matches' (int),
-        and optionally 'error' (str) if something went wrong
-    
-    Example:
-        anchor_search = "<h2>Article 2 - Durée</h2>"
-        insert = "<h3>Article 3 - Prix</h3>"
-        position = "after"
-    """
-
-
-@tool
-async def delete_html(search: str, expected_matches: int = 1) -> Dict[str, Any]:
-    """
-    Delete an exact block of HTML from document.
-    
-    This is a convenience wrapper around replace_html with an empty replacement.
-    Useful for removing unwanted sections, clauses, or content.
-    
-    Args:
-        search: The exact HTML block to delete (must match exactly)
-        expected_matches: Expected number of occurrences (default: 1)
-    
-    Returns:
-        Dict with 'ok' (bool), 'doc_text' (updated HTML), 'matches' (int),
-        and optionally 'error' (str) if something went wrong
-    
-    Example:
-        search = "<p>This paragraph should be deleted</p>"
-    """
-
-
-@tool
-async def inspect_document() -> Dict[str, Any]:
+async def inspect_document(doc_text: str = None) -> Dict[str, Any]:
     """
     Return the current state of the document.
     
@@ -305,14 +244,17 @@ async def inspect_document() -> Dict[str, Any]:
     This adds the document state to the conversation context so you can verify
     previous edits and understand the current structure.
     
-    The doc_text is automatically injected from the current state.
+    The document content will be automatically injected from the workflow state.
     
     Returns:
-        Dict with the current document content
+        Dict with 'ok' (bool) and 'content' (str) containing the HTML document
     """
-    # doc_text will be injected from state in _tools_node
+    # Note: doc_text is injected by _tools_node in doc_editor.py
+    # but we accept it as optional parameter for backward compatibility with tests
+    logger.info(f"  🔍 inspect_document | size:{len(doc_text) if doc_text else 0}b")
     return {
-        "ok": True
+        "ok": True,
+        "content": doc_text
     }
 
 
@@ -334,4 +276,4 @@ async def attempt_completion(message: str) -> Dict[str, Any]:
     return {
         "ok": True,
         "message": message
-    }
+    }