logging and html format

agent_api.py

@@ -351,37 +351,65 @@ class CyberLegalAPI:
     
     async def create_or_edit_document(self, request: DocCreatorRequest) -> DocCreatorResponse:
         """
-        Create or edit a TipTap document using the document editor agent
+        Create or edit an HTML document using the document editor agent
         Args:
-            request: Document editing request with TipTap JSON content
+            request: Document editing request with HTML content
         Returns:
             DocCreatorResponse with assistant's response and modified document
         """
         start_time = datetime.now()
+        
+        # Log incoming request details
+        logger.info("=" * 80)
+        logger.info("📥 DOC_CREATOR REQUEST RECEIVED")
+        logger.info("=" * 80)
+        logger.info(f"👤 Client ID: {request.clientId}")
+        logger.info(f"📋 Instruction: {request.instruction}")
+        logger.info(f"📏 Document size: {len(request.documentContent)} bytes")
+        logger.info(f"📚 Document summaries: {len(request.documentSummaries) if request.documentSummaries else 0}")
+        logger.info(f"💬 Conversation history: {len(request.conversationHistory) if request.conversationHistory else 0} messages")
+        
         try:
-            # Convert TipTap JSON to canonical format
-            logger.info(f"📝 Processing document edit request")
-            # Convert to canonical JSON (sorted keys, 2-space indent)
-            doc_text = json.dumps(request.documentContent, ensure_ascii=False, sort_keys=True, indent=2)
+            # Use HTML directly (no canonicalization needed)
+            logger.info("🔄 Using HTML document content directly...")
+            doc_text = request.documentContent
+            logger.info(f"✅ HTML document ready - size: {len(doc_text)} bytes")
+            
             # Convert document summaries if provided
             doc_summaries = []
             if request.documentSummaries:
-                for doc in request.documentSummaries:
+                logger.info("📚 Processing document summaries...")
+                for i, doc in enumerate(request.documentSummaries, 1):
+                    logger.info(f"  [{i}] {doc.file_name} - {doc.summary[:50]}...")
                     doc_summaries.append({
                         "file_name": doc.file_name,
                         "summary": doc.summary,
                         "actors": doc.actors,
                         "key_details": doc.key_details
                     })
+                logger.info(f"✅ {len(doc_summaries)} document summaries loaded")
+            else:
+                logger.info("ℹ️ No document summaries provided")
+            
             # Convert conversation history if provided
             conversation_history = []
-            for msg in request.conversationHistory or []:
-                conversation_history.append({
-                    "role": msg.role,
-                    "content": msg.content
-                })
+            if request.conversationHistory:
+                logger.info(f"💬 Processing conversation history ({len(request.conversationHistory)} messages)...")
+                for i, msg in enumerate(request.conversationHistory, 1):
+                    role_emoji = "👤" if msg.role == "user" else "🤖"
+                    logger.info(f"  [{i}] {role_emoji} {msg.role}: {msg.content[:50]}...")
+                    conversation_history.append({
+                        "role": msg.role,
+                        "content": msg.content
+                    })
+                logger.info(f"✅ {len(conversation_history)} conversation messages loaded")
+            else:
+                logger.info("ℹ️ No conversation history provided")
+            
             # Call document editor agent
-            logger.info(f"🤖 Calling document editor agent")
+            logger.info("=" * 80)
+            logger.info("🤖 CALLING DOCUMENT EDITOR AGENT")
+            logger.info("=" * 80)
             result = await self.doc_editor.edit_document(
                 doc_text=doc_text,
                 user_instruction=request.instruction,
@@ -389,15 +417,25 @@ class CyberLegalAPI:
                 conversation_history=conversation_history,
                 max_iterations=10
             )
+            
             # Calculate processing time
             processing_time = (datetime.now() - start_time).total_seconds()
-            # Prepare response
-            modified_document = None
+            
+            # Log results
+            logger.info("=" * 80)
+            logger.info("📊 DOCUMENT EDITING RESULTS")
+            logger.info("=" * 80)
+            logger.info(f"✅ Success: {result['success']}")
+            logger.info(f"🔄 Iterations: {result['iteration_count']}")
+            logger.info(f"⏱️ Processing time: {processing_time:.2f}s")
+            logger.info(f"💬 Message: {result['message'][:100]}...")
+            
+            # Prepare response - return HTML directly
+            modified_document = result['doc_text'] if result['success'] else None
             if result['success']:
-                try:
-                    modified_document = json.loads(result['doc_text'])
-                except Exception as e:
-                    logger.error(f"❌ Failed to parse modified document: {e}")
+                logger.info(f"📏 Modified document size: {len(result['doc_text'])} bytes")
+                logger.info(f"📈 Size change: {len(result['doc_text']) - len(doc_text):+d} bytes")
+            
             response = DocCreatorResponse(
                 response=result['message'],
                 modifiedDocument=modified_document,
@@ -406,7 +444,9 @@ class CyberLegalAPI:
                 error=None if result['success'] else result.get('message')
             )
             
-            logger.info(f"✅ Document editing completed in {processing_time:.2f}s")
+            logger.info("=" * 80)
+            logger.info("✅ DOCUMENT EDITING COMPLETED SUCCESSFULLY")
+            logger.info("=" * 80)
             return response
             
         except Exception as e:
@@ -463,25 +503,35 @@ async def chat_endpoint(request: ChatRequest):
 @app.post("/doc_creator", response_model=DocCreatorResponse, dependencies=[Depends(require_password)])
 async def doc_creator_endpoint(request: DocCreatorRequest):
     """
-    Document creator/editor endpoint for TipTap JSON documents
+    Document creator/editor endpoint for HTML documents
     
     Args:
         request: Document editing request
         - instruction: User's instruction for document editing
-        - documentContent: TipTap JSON document content
-        - contentFormat: Always "tiptap-json"
+        - documentContent: HTML document content
+        - contentFormat: Always "html"
         - documentSummaries: Optional context from analyzed documents
         - conversationHistory: Optional previous conversation messages
         - clientId: Unique client identifier
     
     Returns:
         DocCreatorResponse with assistant's response and modified document
+        
+        On success:
+        - response: Completion message
+        - modifiedDocument: Modified HTML
+        - error: null
+        
+        On failure (validation error or max iterations reached):
+        - response: Error message
+        - modifiedDocument: null
+        - error: Error description
     
     Usage:
-        - Send TipTap JSON from editor.getJSON() in documentContent
+        - Send HTML content in documentContent
         - Provide clear instructions for modifications
         - Optionally include document summaries for context
-        - Returns modified TipTap JSON ready for editor.setContent()
+        - Returns modified HTML ready for display
     
     Supported Operations:
         - Replace text: "Change '12 months' to '24 months'"
@@ -489,18 +539,16 @@ async def doc_creator_endpoint(request: DocCreatorRequest):
         - Delete content: "Remove the section about confidentiality"
         - Complex edits: "Add a clause about GDPR compliance in Article 1"
     
-    Example TipTap JSON structure:
-        {
-          "type": "doc",
-          "content": [
-            {
-              "type": "paragraph",
-              "content": [
-                {"type": "text", "text": "Hello world"}
-              ]
-            }
-          ]
-        }
+    Example HTML structure:
+        <h1>Contract</h1>
+        <h2>Article 1 - Duration</h2>
+        <p>This contract shall last for 12 months.</p>
+    
+    Error Handling:
+        - The agent validates all modifications with BeautifulSoup
+        - If a modification is invalid (HTML structure broken), the agent automatically retries
+        - If max iterations (10) is reached without completion, an error is returned
+        - Check the 'error' field in the response to detect failures
     """
     return await api.create_or_edit_document(request)
 

prompts/doc_editor.py

@@ -3,7 +3,7 @@
 System prompts for the document editor agent
 """
 
-DOC_EDITOR_SYSTEM_PROMPT = """You are a Document Editing Agent specialized in modifying TipTap JSON documents.
+DOC_EDITOR_SYSTEM_PROMPT = """You are a Document Editing Agent specialized in modifying HTML documents.
 
 ## CRITICAL RULES
 
@@ -11,47 +11,47 @@ DOC_EDITOR_SYSTEM_PROMPT = """You are a Document Editing Agent specialized in mo
 
 2. **NEVER OUTPUT THE FULL DOCUMENT**: Never output the complete document text. The system always has the current document state.
 
-3. **EXACT MATCHING**: When using replace/add/delete, you must copy the EXACT text block from the canonical JSON (including all whitespace, quotes, and indentation). The search/anchor must match exactly.
+3. **EXACT MATCHING**: When using replace/add/delete, you must copy the EXACT HTML block (including all whitespace, tags, attributes, and attributes values). The search/anchor must match exactly.
 
 4. **ALWAYS INCLUDE expected_matches**: Always specify the expected_matches parameter (usually 1) to prevent unintended multiple replacements.
 
 5. **SMALL, PRECISE EDITS**: Make small, targeted edits. Don't try to replace large blocks - select the smallest unique fragment that identifies what you want to change.
 
-6. **VALIDATE YOUR CHOICES**: If a tool returns an error (mismatch or invalid JSON), analyze the error and try again with a more precise search/anchor.
+6. **VALIDATE YOUR CHOICES**: If a tool returns an error (mismatch or invalid HTML), analyze the error and try again with a more precise search/anchor.
 
 7. **CALL attempt_completion WHEN DONE**: Once all modifications are successfully applied, call attempt_completion with a summary message.
 
 ## AVAILABLE TOOLS
 
-### replace
-Replace an exact block of text in the document.
+### replace_html
+Replace an exact block of HTML text in the document.
 
 Parameters:
-- doc_text: (provided automatically) The current canonical document
-- search: The exact text block to replace (must match exactly)
-- replace: The exact text block to insert
+- doc_text: (provided automatically) The current HTML document
+- search: The exact HTML block to replace (must match exactly, including whitespace, tags, and attributes)
+- replace: The exact HTML block to insert
 - expected_matches: Number of occurrences (default: 1)
 
 Example:
 ```json
 {
   "type": "tool_call",
-  "name": "replace",
+  "name": "replace_html",
   "arguments": {
-    "search": "\"text\": \"12 mois\"",
-    "replace": "\"text\": \"24 mois\"",
+    "search": "<p>12 mois</p>",
+    "replace": "<p>24 mois</p>",
     "expected_matches": 1
   }
 }
 ```
 
-### add
-Add content before or after an anchor block.
+### add_html
+Add HTML content before or after an anchor block.
 
 Parameters:
-- doc_text: (provided automatically) The current canonical document
-- anchor_search: The exact text block to find (must match exactly)
-- insert: The exact text block to insert
+- doc_text: (provided automatically) The current HTML document
+- 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: Number of anchor occurrences (default: 1)
 
@@ -59,31 +59,31 @@ Example:
 ```json
 {
   "type": "tool_call",
-  "name": "add",
+  "name": "add_html",
   "arguments": {
-    "anchor_search": "{\n    \"type\": \"heading\",\n    \"attrs\": { \"level\": 2, \"textAlign\": \"left\" },\n    \"content\": [\n      { \"type\": \"text\", \"text\": \"Article 2 - Durée\" }\n    ]\n  }",
-    "insert": ",\n  {\n    \"type\": \"heading\",\n    \"attrs\": { \"level\": 2, \"textAlign\": \"left\" },\n    \"content\": [\n      { \"type\": \"text\", \"text\": \"Article 3 - Prix\" }\n    ]\n  }",
+    "anchor_search": "<h2>Article 2 - Durée</h2>",
+    "insert": "<h3>Article 3 - Prix</h3>",
     "position": "after",
     "expected_matches": 1
   }
 }
 ```
 
-### delete
-Delete an exact block of text.
+### delete_html
+Delete an exact block of HTML from the document.
 
 Parameters:
-- doc_text: (provided automatically) The current canonical document
-- search: The exact text block to delete (must match exactly)
+- doc_text: (provided automatically) The current HTML document
+- search: The exact HTML block to delete (must match exactly)
 - expected_matches: Number of occurrences (default: 1)
 
 Example:
 ```json
 {
   "type": "tool_call",
-  "name": "delete",
+  "name": "delete_html",
   "arguments": {
-    "search": "{\n    \"type\": \"paragraph\",\n    \"attrs\": { \"textAlign\": \"justify\" },\n    \"content\": [\n      { \"type\": \"text\", \"text\": \"Unwanted text\" }\n    ]\n  }",
+    "search": "<p>Unwanted text</p>",
     "expected_matches": 1
   }
 }
@@ -109,27 +109,28 @@ Example:
 ## ERROR HANDLING
 
 If you receive an error:
-- "Match count mismatch": Your search/anchor didn't match exactly. Check whitespace, quotes, and indentation. Try a more specific or different fragment.
-- "Post-edit validation failed": The replacement broke the JSON structure. Ensure your insert/replace is valid JSON with proper commas and brackets.
+- "Match count mismatch": Your search/anchor didn't match exactly. Check whitespace, tags, attributes, and attribute values. Try a more specific or different fragment.
+- "Post-edit validation failed": The replacement broke the HTML structure. Ensure your insert/replace is valid HTML with proper tags.
 
 ## WORKFLOW
 
 1. Read the instruction and current document
 2. Identify what needs to be changed
-3. Call the appropriate tool (replace/add/delete) with exact text matching
+3. Call the appropriate tool (replace_html/add_html/delete_html) with exact HTML matching
 4. If successful and more changes needed, call the next tool
 5. If all changes done, call attempt_completion
 6. If an error occurs, analyze it and retry with corrected parameters
 
 ## TIPS
 
-- For text content: search for `"text": "exact text here"` - it's usually unique
-- For headings: search for the entire heading node block
+- For text content: search for unique text within tags like `<p>exact text here</p>` - it's usually unique
+- For headings: search for the entire heading tag like `<h2>Article 2 - Durée</h2>`
 - For paragraphs: search for a unique phrase in the text content
-- Always include proper commas in your insert/replace when adding to arrays
-- The document uses TipTap JSON format with nodes like "doc", "heading", "paragraph", "text", etc.
+- Always include proper HTML structure with opening and closing tags
+- Be mindful of HTML attributes - include them exactly as they appear
+- For inline elements like `<strong>`, `<em>`, etc., include the full element with tags
 
-Remember: Exact matching is crucial. Copy the text block exactly as it appears in the canonical JSON!
+Remember: Exact matching is crucial. Copy the HTML block exactly as it appears in the document!
 """
 
 

requirements.txt

@@ -23,3 +23,4 @@ pydantic>=2.0.0
 typing-extensions>=4.0.0
 langchain-tavily>=0.2.16
 resend>=0.8.0
+beautifulsoup4>=4.12.0

structured_outputs/api_models.py

@@ -80,8 +80,8 @@ class AnalyzePDFResponse(BaseModel):
 class DocCreatorRequest(BaseModel):
     """Document creator request model"""
     instruction: str = Field(..., description="User's instruction for document editing")
-    documentContent: dict = Field(..., description="TipTap JSON document content")
-    contentFormat: str = Field(default="tiptap-json", description="Format of document content (always 'tiptap-json')")
+    documentContent: str = Field(..., description="HTML document content")
+    contentFormat: str = Field(default="html", description="Format of document content (always 'html')")
     documentSummaries: Optional[List[DocumentAnalysis]] = Field(default=None, description="Context from analyzed documents")
     conversationHistory: Optional[List[Message]] = Field(default=[], description="Previous conversation messages")
     clientId: str = Field(..., description="Unique client identifier")
@@ -90,7 +90,7 @@ class DocCreatorRequest(BaseModel):
 class DocCreatorResponse(BaseModel):
     """Document creator response model"""
     response: str = Field(..., description="Assistant's response")
-    modifiedDocument: Optional[dict] = Field(None, description="Modified TipTap JSON document (if changes were made)")
+    modifiedDocument: Optional[str] = Field(None, description="Modified HTML document (if changes were made)")
     processing_time: float = Field(..., description="Processing time in seconds")
     timestamp: str = Field(..., description="Response timestamp")
     error: Optional[str] = Field(None, description="Error message if any")

subagents/doc_editor.py

@@ -1,16 +1,17 @@
 #!/usr/bin/env python3
 """
-Document Editor Agent - LangGraph agent for modifying TipTap JSON documents
+Document Editor Agent - LangGraph agent for modifying HTML documents
 Implements Cline-like iterative editing with validation
 """
 
 import logging
+import traceback
 from typing import Dict, Any, List
 from langgraph.graph import StateGraph, END
 from langchain_core.messages import SystemMessage, HumanMessage, AIMessage, ToolMessage
 
 from agent_states.doc_editor_state import DocEditorState
-from utils.doc_editor_tools import replace, add, delete, attempt_completion
+from utils.doc_editor_tools import replace_html, add_html, delete_html, attempt_completion
 from prompts.doc_editor import get_doc_editor_system_prompt
 
 logger = logging.getLogger(__name__)
@@ -18,11 +19,11 @@ logger = logging.getLogger(__name__)
 
 class DocumentEditorAgent:
     """
-    Agent for editing TipTap JSON documents using Cline-like iterative approach.
+    Agent for editing HTML documents using Cline-like iterative approach.
     
     Workflow:
-    1. Agent generates a tool call (replace/add/delete/attempt_completion)
-    2. Tools execute with validation
+    1. Agent generates a tool call (replace_html/add_html/delete_html/attempt_completion)
+    2. Tools execute with BeautifulSoup validation
     3. Check if complete or max iterations reached
     4. Repeat until completion or error
     """
@@ -35,7 +36,7 @@ class DocumentEditorAgent:
             llm: Language model instance (ChatOpenAI or compatible)
         """
         self.llm = llm
-        self.tools = [replace, add, delete, attempt_completion]
+        self.tools = [replace_html, add_html, delete_html, attempt_completion]
         self.llm_with_tools = self.llm.bind_tools(self.tools)
         self.workflow = self._build_workflow()
     
@@ -111,13 +112,20 @@ class DocumentEditorAgent:
         """
         intermediate_steps = state.get("intermediate_steps", [])
         iteration_count = state.get("iteration_count", 0)
+        max_iterations = state.get("max_iterations", 10)
+        current_doc_size = len(state.get("doc_text", ""))
         
-        logger.info(f"🔄 Agent iteration {iteration_count + 1}/{state.get('max_iterations', 10)}")
+        logger.info("")
+        logger.info("=" * 80)
+        logger.info(f"🔄 AGENT ITERATION {iteration_count + 1}/{max_iterations}")
+        logger.info("=" * 80)
+        logger.info(f"📏 Current document size: {current_doc_size} bytes")
         
         # First iteration: add system prompt and user instruction
         if iteration_count == 0:
             system_prompt = get_doc_editor_system_prompt()
             intermediate_steps.append(SystemMessage(content=system_prompt))
+            logger.info("📝 System prompt added")
             
             # Build context message with conversation history and doc_summaries
             conversation_history = state.get("conversation_history", [])
@@ -138,15 +146,19 @@ class DocumentEditorAgent:
             
             # Add document and instruction
             full_message = (
-                f"Current document (TipTap JSON):\n{state['doc_text']}\n\n"
+                f"Current document (HTML):\n{state['doc_text']}\n\n"
                 f"{context_msg}\n\n"
                 f"Instruction: {state['user_instruction']}"
             )
             intermediate_steps.append(HumanMessage(content=full_message))
+            logger.info(f"💬 User message added ({len(full_message)} chars)")
+            logger.info(f"📚 Context: {len(conversation_history)} history + {len(doc_summaries)} summaries")
         
         # Call LLM with tools
+        logger.info("🤖 Calling LLM with tools...")
         response = await self.llm_with_tools.ainvoke(intermediate_steps)
         intermediate_steps.append(response)
+        logger.info("✅ LLM response received")
         
         state["intermediate_steps"] = intermediate_steps
         return state
@@ -159,27 +171,43 @@ class DocumentEditorAgent:
         last_message = intermediate_steps[-1]
         
         if not (hasattr(last_message, 'tool_calls') and last_message.tool_calls):
+            logger.info("ℹ️ No tool calls in last message, returning to agent")
             return state
         
+        logger.info(f"🔧 Executing {len(last_message.tool_calls)} tool call(s)...")
+        
         # Increment iteration count
         state["iteration_count"] = state.get("iteration_count", 0) + 1
         
-        for tool_call in last_message.tool_calls:
+        for i, tool_call in enumerate(last_message.tool_calls, 1):
             tool_name = tool_call['name']
             tool_func = next((t for t in self.tools if t.name == tool_name), None)
             
+            logger.info("")
+            logger.info(f"🔧 Tool {i}/{len(last_message.tool_calls)}: {tool_name}")
+            
             if tool_func:
                 args = tool_call['args'].copy()
                 
                 # Inject current doc_text into tool calls
-                if tool_name in ["replace", "add", "delete"]:
+                if tool_name in ["replace_html", "add_html", "delete_html"]:
                     args["doc_text"] = state["doc_text"]
-                    logger.info(f"📝 Injecting doc_text to {tool_name}")
+                    logger.info(f"📝 Injecting doc_text ({len(state['doc_text'])} bytes) to {tool_name}")
+                
+                # Log tool arguments (sanitized)
+                safe_args = {k: v for k, v in args.items() if k != 'doc_text'}
+                if tool_name in ["replace_html", "add_html", "delete_html"]:
+                    safe_args["doc_text"] = f"<{len(args['doc_text'])} bytes>"
+                logger.info(f"📥 Arguments: {safe_args}")
                 
                 # Execute tool
                 try:
                     result = await tool_func.ainvoke(args)
-                    logger.info(f"🔧 Tool {tool_name} result: ok={result.get('ok')}, matches={result.get('matches')}")
+                    logger.info(f"🔧 Tool {tool_name} executed:")
+                    logger.info(f"  ✅ ok={result.get('ok')}")
+                    logger.info(f"  🔍 matches={result.get('matches')}")
+                    if result.get("ok") and "doc_text" in result:
+                        logger.info(f"  📏 New doc_text size: {len(result['doc_text'])} bytes")
                     
                     # Update doc_text if tool was successful
                     if result.get("ok") and "doc_text" in result:
@@ -201,6 +229,7 @@ class DocumentEditorAgent:
                 except Exception as e:
                     error_msg = f"Error executing {tool_name}: {str(e)}"
                     logger.error(f"❌ {error_msg}")
+                    logger.error(f"🔍 Traceback: {traceback.format_exc()}")
                     intermediate_steps.append(
                         ToolMessage(
                             content=error_msg,
@@ -224,7 +253,7 @@ class DocumentEditorAgent:
         Edit a document according to the user instruction.
         
         Args:
-            doc_text: Canonical TipTap JSON string (use sort_keys=True, indent=2)
+            doc_text: HTML document string
             user_instruction: What changes to make to the document
             doc_summaries: Optional summaries of the document for context
             conversation_history: Optional previous conversation messages for context
@@ -232,11 +261,31 @@ class DocumentEditorAgent:
         
         Returns:
             Dict with:
-                - doc_text: Modified document (canonical JSON)
+                - doc_text: Modified document (HTML)
                 - message: Completion message or error description
                 - success: Boolean indicating success
                 - iteration_count: Number of iterations performed
         """
+        # Log initial state
+        logger.info("=" * 80)
+        logger.info("🎯 DOCUMENT EDITOR AGENT STARTING")
+        logger.info("=" * 80)
+        logger.info(f"📏 Initial document size: {len(doc_text)} bytes")
+        logger.info(f"📋 Instruction: {user_instruction[:100]}{'...' if len(user_instruction) > 100 else ''}")
+        logger.info(f"📚 Document summaries: {len(doc_summaries)}")
+        logger.info(f"💬 Conversation history: {len(conversation_history)} messages")
+        logger.info(f"🔄 Max iterations: {max_iterations}")
+        
+        if doc_summaries:
+            logger.info("📚 Document summaries loaded:")
+            for i, summary in enumerate(doc_summaries[:3], 1):  # Show first 3
+                logger.info(f"  [{i}] {str(summary)[:100]}...")
+            if len(doc_summaries) > 3:
+                logger.info(f"  ... and {len(doc_summaries) - 3} more")
+        
+        if conversation_history:
+            logger.info(f"💬 Conversation history loaded ({len(conversation_history)} messages)")
+        
         # Initialize state
         initial_state = {
             "doc_text": doc_text,
@@ -249,34 +298,52 @@ class DocumentEditorAgent:
             "intermediate_steps": []
         }
         
-        logger.info(f"🚀 Starting document editing: {user_instruction}")
+        logger.info("🎯 Initial state prepared, starting workflow...")
         
         # Run workflow
         try:
+            logger.info("🔄 Invoking LangGraph workflow...")
             final_state = await self.workflow.ainvoke(initial_state)
             
             # Prepare result
             success = final_state.get("completion_message") is not None
             message = final_state.get("completion_message") or "Editing completed without explicit completion message"
             
+            iteration_count = final_state.get("iteration_count", 0)
+            final_doc_size = len(final_state["doc_text"])
+            size_change = final_doc_size - len(doc_text)
+            
+            logger.info("=" * 80)
+            logger.info("📊 DOCUMENT EDITING COMPLETED")
+            logger.info("=" * 80)
+            logger.info(f"✅ Success: {success}")
+            logger.info(f"🔄 Iterations: {iteration_count}")
+            logger.info(f"📏 Final document size: {final_doc_size} bytes")
+            logger.info(f"📈 Size change: {size_change:+d} bytes ({size_change/len(doc_text)*100:+.1f}%)")
+            logger.info(f"💬 Message: {message[:100]}{'...' if len(message) > 100 else ''}")
+            
             if not success:
-                iteration_count = final_state.get("iteration_count", 0)
                 max_iters = final_state.get("max_iterations", 10)
                 if iteration_count >= max_iters:
+                    logger.warning(f"⚠️ Failed to complete editing within {max_iters} iterations")
                     message = f"Failed to complete editing within {max_iters} iterations"
             
             return {
                 "doc_text": final_state["doc_text"],
                 "message": message,
                 "success": success,
-                "iteration_count": final_state["iteration_count"]
+                "iteration_count": iteration_count
             }
         
         except Exception as e:
-            logger.error(f"❌ Error in document editing workflow: {e}")
+            logger.error("=" * 80)
+            logger.error("❌ DOCUMENT EDITING FAILED")
+            logger.error("=" * 80)
+            logger.error(f"❌ Error: {str(e)}")
+            logger.error(f"🔍 Traceback: {traceback.format_exc()}")
             return {
                 "doc_text": doc_text,  # Return original on error
                 "message": f"Error during editing: {str(e)}",
                 "success": False,
                 "iteration_count": 0
-            }
+            }

tests/test_logging_doc_editor.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""
+Test script to verify detailed logging in document editor
+"""
+
+import json
+import logging
+import sys
+import os
+import asyncio
+from datetime import datetime
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from utils.doc_editor_tools import replace, add, delete, attempt_completion
+from subagents.doc_editor import DocumentEditorAgent
+from langchain_openai import ChatOpenAI
+
+# Configure detailed logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s | %(levelname)-8s | %(name)s | %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S',
+    stream=sys.stdout
+)
+
+logger = logging.getLogger(__name__)
+
+def test_tool_logging():
+    """Test logging in individual tools"""
+    print("\n" + "=" * 80)
+    print("TEST 1: Testing Tool Logging")
+    print("=" * 80)
+    
+    # Sample TipTap JSON
+    doc = {
+        "type": "doc",
+        "content": [
+            {
+                "type": "heading",
+                "attrs": {"level": 1, "textAlign": "center"},
+                "content": [{"type": "text", "text": "Document de test"}]
+            },
+            {
+                "type": "paragraph",
+                "content": [{"type": "text", "text": "Ceci est un test du document editor."}]
+            }
+        ]
+    }
+    
+    # Convert to canonical format
+    doc_text = json.dumps(doc, ensure_ascii=False, sort_keys=True, indent=2)
+    
+    print(f"\n📏 Initial document: {len(doc_text)} bytes")
+    print(f"\nInitial document:")
+    print(doc_text)
+    
+    # Test 1: Replace
+    print("\n" + "-" * 80)
+    print("TEST 1.1: Replace Tool")
+    print("-" * 80)
+    result = replace.invoke({
+        "doc_text": doc_text,
+        "search": '"text": "test"',
+        "replace": '"text": "example"',
+        "expected_matches": 1
+    })
+    print(f"\nResult: {json.dumps(result, indent=2)}")
+    
+    if result.get("ok"):
+        print("\n✅ Replace test PASSED")
+        print(f"Updated document ({len(result['doc_text'])} bytes):")
+        print(result['doc_text'])
+    else:
+        print(f"\n❌ Replace test FAILED: {result.get('error')}")
+    
+    # Test 2: Add
+    print("\n" + "-" * 80)
+    print("TEST 1.2: Add Tool")
+    print("-" * 80)
+    if result.get("ok"):
+        new_doc_text = result['doc_text']
+        add_result = add.invoke({
+            "doc_text": new_doc_text,
+            "anchor_search": '"text": "Document de example"',
+            "insert": ',\n    {"type": "text", "marks": [{"type": "bold"}], "text": " - Version 1.0"}',
+            "position": "after",
+            "expected_matches": 1
+        })
+        print(f"\nResult: {json.dumps(add_result, indent=2)}")
+        
+        if add_result.get("ok"):
+            print("\n✅ Add test PASSED")
+            print(f"Updated document ({len(add_result['doc_text'])} bytes):")
+            print(add_result['doc_text'])
+        else:
+            print(f"\n❌ Add test FAILED: {add_result.get('error')}")
+    
+    # Test 3: Delete
+    print("\n" + "-" * 80)
+    print("TEST 1.3: Delete Tool")
+    print("-" * 80)
+    delete_result = delete.invoke({
+        "doc_text": doc_text,
+        "search": '"text": "Document de test"',
+        "expected_matches": 1
+    })
+    print(f"\nResult: {json.dumps(delete_result, indent=2)}")
+    
+    if delete_result.get("ok"):
+        print("\n✅ Delete test PASSED")
+    else:
+        print(f"\n❌ Delete test FAILED: {delete_result.get('error')}")
+
+async def test_agent_logging():
+    """Test logging in document editor agent"""
+    print("\n" + "=" * 80)
+    print("TEST 2: Testing Agent Logging")
+    print("=" * 80)
+    
+    # Sample document
+    doc = {
+        "type": "doc",
+        "content": [
+            {
+                "type": "paragraph",
+                "content": [{"type": "text", "text": "Ceci est un document de test."}]
+            }
+        ]
+    }
+    
+    doc_text = json.dumps(doc, ensure_ascii=False, sort_keys=True, indent=2)
+    
+    print(f"\n📏 Initial document: {len(doc_text)} bytes")
+    print(f"📋 Instruction: Replace 'test' with 'example'")
+    
+    # Check if we have API key
+    if not os.getenv("OPENAI_API_KEY"):
+        print("\n⚠️ OPENAI_API_KEY not set, skipping agent test")
+        return
+    
+    try:
+        # Initialize LLM
+        llm = ChatOpenAI(
+            model=os.getenv("LLM_MODEL", "gpt-4o-mini"),
+            api_key=os.getenv("OPENAI_API_KEY"),
+            base_url=os.getenv("LLM_BINDING_HOST", "https://api.openai.com/v1")
+        )
+        
+        # Initialize agent
+        agent = DocumentEditorAgent(llm=llm)
+        
+        # Run agent
+        result = await agent.edit_document(
+            doc_text=doc_text,
+            user_instruction="Replace 'test' with 'example'",
+            max_iterations=3
+        )
+        
+        print(f"\n📊 Agent Result:")
+        print(f"  ✅ Success: {result['success']}")
+        print(f"  🔄 Iterations: {result['iteration_count']}")
+        print(f"  💬 Message: {result['message']}")
+        
+        if result['success']:
+            print(f"\n✅ Agent test PASSED")
+            print(f"📏 Final document size: {len(result['doc_text'])} bytes")
+        else:
+            print(f"\n❌ Agent test FAILED")
+    
+    except Exception as e:
+        print(f"\n❌ Agent test failed with error: {e}")
+        import traceback
+        traceback.print_exc()
+
+if __name__ == "__main__":
+    print("\n" + "=" * 80)
+    print("DOCUMENT EDITOR LOGGING TEST")
+    print("=" * 80)
+    print(f"Started at: {datetime.now().isoformat()}")
+    
+    # Test tools logging
+    test_tool_logging()
+    
+    # Test agent logging (if API key available)
+    # Uncomment to test with actual LLM calls
+    # asyncio.run(test_agent_logging())
+    
+    print("\n" + "=" * 80)
+    print("TEST COMPLETED")
+    print("=" * 80)
+    print(f"Ended at: {datetime.now().isoformat()}")

utils/doc_editor_tools.py

@@ -1,53 +1,93 @@
 #!/usr/bin/env python3
 """
-Document editor tools for TipTap JSON modification
-Implements Cline-like text-based editing with exact match + validation
+Document editor tools for HTML modification
+Implements Cline-like text-based editing with exact match + BeautifulSoup validation for HTML
 """
 
-import json
-from typing import Literal, Dict, Any, Optional
+import logging
+from typing import Literal, Dict, Any
+from bs4 import BeautifulSoup
 from langchain_core.tools import tool
 
-
-def _canon(obj: Any) -> str:
-    """
-    Canonical pretty-print: stable key order + stable indentation.
-    IMPORTANT: Always send *this* representation to the LLM, otherwise SEARCH won't match.
-    """
-    return json.dumps(obj, ensure_ascii=False, sort_keys=True, indent=2)
+logger = logging.getLogger(__name__)
 
 
-def _parse_tiptap(doc_text: str) -> Dict[str, Any]:
+async def _validate_html(html: str) -> tuple[bool, str]:
     """
-    Parse and validate TipTap JSON structure.
-    Raises ValueError if structure is invalid.
+    Validate HTML structure using BeautifulSoup.
+    
+    BeautifulSoup is very tolerant and will parse even malformed HTML.
+    We use it to ensure the HTML is at least parseable and contains some content.
+    
+    Args:
+        html: The HTML string to validate
+    
+    Returns:
+        tuple[bool, str]: (is_valid, error_message)
     """
+    if not html or not html.strip():
+        return False, "HTML document is empty"
+    
     try:
-        doc = json.loads(doc_text)
-    except json.JSONDecodeError as e:
-        raise ValueError(f"Invalid JSON: {e}")
-    
-    # Minimal TipTap validation
-    if not isinstance(doc, dict):
-        raise ValueError("Root must be a JSON object (dict).")
-    if doc.get("type") != "doc":
-        raise ValueError("Root.type must be 'doc'.")
-    if "content" not in doc:
-        raise ValueError("Root must have 'content' field.")
-    if not isinstance(doc.get("content"), list):
-        raise ValueError("Root.content must be a list.")
-    
-    return doc
+        # Parse the HTML (html.parser is included in stdlib)
+        soup = BeautifulSoup(html, 'html.parser')
+        
+        # Get the normalized HTML
+        normalized = str(soup)
+        
+        # Check if there's any content
+        if not normalized.strip():
+            return False, "HTML document is empty after parsing"
+        
+        # Check if there are any HTML tags
+        if len(soup.find_all()) == 0:
+            return False, "HTML document contains no HTML tags"
+        
+        # Check for obvious structural issues
+        # BeautifulSoup will have already failed if the HTML is completely unparsable
+        # So at this point we know it's at least somewhat valid
+        
+        return True, "OK"
+        
+    except Exception as e:
+        return False, f"HTML parsing failed: {str(e)}"
 
 
-def _replace_func(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 function for replacing text blocks.
-    This is the actual implementation used by the replace and delete tools.
+    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:
+        doc_text: The HTML document content
+        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>"
     """
+    logger.info("  🔧 TOOL: replace_html")
+    
+    # Log operation details
+    logger.info(f"  🔍 SEARCH pattern ({len(search)} chars): {search[:80]}{'...' if len(search) > 80 else ''}")
+    logger.info(f"  ✏️ REPLACE pattern ({len(replace)} chars): {replace[:80]}{'...' if len(replace) > 80 else ''}")
+    logger.info(f"  🎯 Expected matches: {expected_matches}")
+    
     # Count exact matches
     m = doc_text.count(search) if search else 0
+    logger.info(f"  🔢 Actual matches found: {m}")
+    
     if m != expected_matches:
+        logger.warning(f"  ⚠️ Match count mismatch: found {m}, expected {expected_matches}")
         return {
             "ok": False,
             "error": f"Match count mismatch: found {m} occurrences, expected {expected_matches}",
@@ -55,17 +95,31 @@ def _replace_func(doc_text: str, search: str, replace: str, expected_matches: in
         }
     
     # Perform replacement
+    logger.info("  ✏️ Performing replacement...")
     new_text = doc_text.replace(search, replace, expected_matches)
+    size_change = len(new_text) - len(doc_text)
+    logger.info(f"  📏 Size change: {size_change:+d} bytes ({size_change/len(doc_text)*100:+.1f}%)")
     
-    # Validate the result
+    # Validate result with BeautifulSoup
     try:
-        doc = _parse_tiptap(new_text)
+        logger.info("  ✔️ Validating HTML structure...")
+        is_valid, error_msg = await _validate_html(new_text)
+        if not is_valid:
+            logger.error(f"  ❌ Validation failed: {error_msg}")
+            return {
+                "ok": False,
+                "error": f"Post-edit validation failed: {error_msg}",
+                "matches": m
+            }
+        logger.info("  ✅ HTML validation passed")
+        logger.info(f"  📏 New doc size: {len(new_text)} bytes")
         return {
             "ok": True,
-            "doc_text": _canon(doc),
+            "doc_text": new_text,
             "matches": m
         }
     except Exception as e:
+        logger.error(f"  ❌ Validation failed: {e}")
         return {
             "ok": False,
             "error": f"Post-edit validation failed: {e}",
@@ -74,50 +128,43 @@ def _replace_func(doc_text: str, search: str, replace: str, expected_matches: in
 
 
 @tool
-def replace(doc_text: str, search: str, replace: str, expected_matches: int = 1) -> Dict[str, Any]:
+async def add_html(doc_text: str, anchor_search: str, insert: str,
+                   position: Literal["before", "after"] = "after", 
+                   expected_matches: int = 1) -> Dict[str, Any]:
     """
-    Replace an exact block of text in the TipTap JSON document.
-    
-    This tool performs exact string matching on the canonical JSON representation.
-    It's critical that the 'search' parameter matches exactly (including whitespace and quotes).
-    
-    Args:
-        doc_text: The canonical TipTap JSON string
-        search: The exact text block to replace (must match exactly)
-        replace: The exact text block to insert
-        expected_matches: Expected number of occurrences (default: 1)
-    
-    Returns:
-        Dict with 'ok' (bool), 'doc_text' (updated canonical JSON), 'matches' (int),
-        and optionally 'error' (str) if something went wrong
-    """
-    return _replace_func(doc_text=doc_text, search=search, replace=replace, expected_matches=expected_matches)
-
-
-@tool
-def add(doc_text: str, anchor_search: str, insert: str,
-        position: Literal["before", "after"] = "after", 
-        expected_matches: int = 1) -> Dict[str, Any]:
-    """
-    Add content before or after an anchor block in the TipTap JSON document.
+    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 articles, clauses, or sections.
+    Useful for adding new paragraphs, sections, or elements.
     
     Args:
-        doc_text: The canonical TipTap JSON string
-        anchor_search: The exact text block to find (must match exactly)
-        insert: The exact text block to insert
+        doc_text: The HTML document content
+        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 canonical JSON), 'matches' (int),
+        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("  🔧 TOOL: add_html")
+    logger.info(f"  📍 Position: {position}")
+    logger.info(f"  🔍 ANCHOR pattern ({len(anchor_search)} chars): {anchor_search[:80]}{'...' if len(anchor_search) > 80 else ''}")
+    logger.info(f"  ✏️ INSERT pattern ({len(insert)} chars): {insert[:80]}{'...' if len(insert) > 80 else ''}")
+    logger.info(f"  🎯 Expected matches: {expected_matches}")
+    
     # Count exact matches of anchor
     m = doc_text.count(anchor_search) if anchor_search else 0
+    logger.info(f"  🔢 Actual anchor matches found: {m}")
+    
     if m != expected_matches:
+        logger.warning(f"  ⚠️ Anchor match count mismatch: found {m}, expected {expected_matches}")
         return {
             "ok": False,
             "error": f"Anchor match count mismatch: found {m} occurrences, expected {expected_matches}",
@@ -125,20 +172,35 @@ def add(doc_text: str, anchor_search: str, insert: str,
         }
     
     # Insert before or after anchor
+    logger.info(f"  ✏️ Inserting content {position} anchor...")
     if position == "before":
         new_text = doc_text.replace(anchor_search, insert + anchor_search, 1)
     else:  # after
         new_text = doc_text.replace(anchor_search, anchor_search + insert, 1)
     
-    # Validate the result
+    size_change = len(new_text) - len(doc_text)
+    logger.info(f"  📏 Size change: {size_change:+d} bytes ({size_change/len(doc_text)*100:+.1f}%)")
+    
+    # Validate result with BeautifulSoup
     try:
-        doc = _parse_tiptap(new_text)
+        logger.info("  ✔️ Validating HTML structure...")
+        is_valid, error_msg = await _validate_html(new_text)
+        if not is_valid:
+            logger.error(f"  ❌ Validation failed: {error_msg}")
+            return {
+                "ok": False,
+                "error": f"Post-edit validation failed: {error_msg}",
+                "matches": m
+            }
+        logger.info("  ✅ HTML validation passed")
+        logger.info(f"  📏 New doc size: {len(new_text)} bytes")
         return {
             "ok": True,
-            "doc_text": _canon(doc),
+            "doc_text": new_text,
             "matches": m
         }
     except Exception as e:
+        logger.error(f"  ❌ Validation failed: {e}")
         return {
             "ok": False,
             "error": f"Post-edit validation failed: {e}",
@@ -147,27 +209,39 @@ def add(doc_text: str, anchor_search: str, insert: str,
 
 
 @tool
-def delete(doc_text: str, search: str, expected_matches: int = 1) -> Dict[str, Any]:
+async def delete_html(doc_text: str, search: str, expected_matches: int = 1) -> Dict[str, Any]:
     """
-    Delete an exact block of text from the TipTap JSON document.
+    Delete an exact block of HTML from the document.
     
-    This is a convenience wrapper around replace with an empty replacement.
+    This is a convenience wrapper around replace_html with an empty replacement.
     Useful for removing unwanted sections, clauses, or content.
     
     Args:
-        doc_text: The canonical TipTap JSON string
-        search: The exact text block to delete (must match exactly)
+        doc_text: The HTML document content
+        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 canonical JSON), 'matches' (int),
+        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>"
     """
-    return _replace_func(doc_text=doc_text, search=search, replace="", expected_matches=expected_matches)
+    logger.info("  🔧 TOOL: delete_html")
+    result = await replace_html.invoke({
+        "doc_text": doc_text,
+        "search": search,
+        "replace": "",
+        "expected_matches": expected_matches
+    })
+    if result.get("ok"):
+        logger.info(f"  🗑️ Deleted {len(search)} characters")
+    return result
 
 
 @tool
-def attempt_completion(message: str) -> Dict[str, Any]:
+async def attempt_completion(message: str) -> Dict[str, Any]:
     """
     Signal that document editing is complete and provide a summary message.
     
@@ -180,6 +254,8 @@ def attempt_completion(message: str) -> Dict[str, Any]:
     Returns:
         Dict with 'ok' (bool) and 'message' (str)
     """
+    logger.info("  ✅ TOOL: attempt_completion")
+    logger.info(f"  📝 Completion message: {message}")
     return {
         "ok": True,
         "message": message