doc editor revamp

prompts/doc_editor.py

@@ -88,26 +88,24 @@ Example:
 }
 ```
 
-### inspect_document
-View the current document state in the conversation history.
-
-Use this tool to see the current document content after previous edits. This adds the document to the message history so you can verify modifications and understand the current structure before making further changes.
+### view_current_document
+View the current state of the document being edited.
+Use this tool to see the current document content after modifications. This helps you verify previous edits and understand the current structure.
 
 Parameters:
-- (no parameters - document is provided automatically)
+- (no parameters - document content is provided automatically)
 
 Example:
 ```json
 {
   "type": "tool_call",
-  "name": "inspect_document",
+  "name": "view_current_document",
   "arguments": {}
 }
 ```
 
 ### attempt_completion
 Signal that all modifications are complete.
-
 Parameters:
 - message: A summary message describing what was changed
 

subagents/doc_editor.py

@@ -3,7 +3,7 @@
 Document Editor Agent - LangGraph agent for modifying HTML documents
 Implements Cline-like iterative editing with validation
 """
-
+import uuid
 import logging
 import traceback
 from typing import Dict, Any, List, Optional
@@ -12,7 +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, view_current_document, attempt_completion
 )
 from prompts.doc_editor import get_doc_editor_system_prompt, get_summary_system_prompt
 from utils.update_notifier import push_document_update
@@ -21,30 +21,19 @@ logger = logging.getLogger(__name__)
 
 
 class DocumentEditorAgent:
-    """
-    Agent for editing HTML documents using Cline-like iterative approach.
-    
-    Workflow:
-    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
-    """
+    """Agent for editing HTML documents using Cline-like iterative approach."""
     
     def __init__(self, llm, llm_tool_calling):
         """
         Initialize the document editor agent.
         
         Args:
-            llm: LLM principal (OpenAI) pour la génération du résumé final
-            llm_tool_calling: LLM (Gemini) pour les tool calls
+            llm: LLM principal pour la génération du résumé final
+            llm_tool_calling: LLM pour les tool calls
         """
-        self.llm = llm  # OpenAI pour le résumé
-        self.llm_tool_calling = llm_tool_calling  # Gemini pour les tool calls
-        # All tools are LangChain tools with @tool decorator
-        self.tools = [replace_html, add_html, delete_html, inspect_document, attempt_completion]
-        # Force at least one tool call at each iteration using tool_choice="any"
-        # Use Gemini for tool calling (better quality output)
+        self.llm = llm
+        self.llm_tool_calling = llm_tool_calling
+        self.tools = [replace_html, add_html, delete_html, view_current_document, attempt_completion]
         self.llm_with_tools = self.llm_tool_calling.bind_tools(self.tools, tool_choice="any")
         logger.info("🔧 Tool binding configured with tool_choice='any' to force tool calls")
         logger.info(f"🤖 Using {type(llm_tool_calling).__name__} for tool calling")
@@ -58,32 +47,18 @@ class DocumentEditorAgent:
         workflow.add_node("tools", self._tools_node)
         workflow.add_node("summary", self._summary_node)
         workflow.set_entry_point("agent")
-        workflow.add_conditional_edges(
-            "agent", 
-            self._should_continue, 
-            {"continue": "tools", "end": END}
-        )
-        workflow.add_conditional_edges(
-            "tools", 
-            self._after_tools, 
-            {"continue": "agent", "summary": "summary", "end": END}
-        )
+        workflow.add_conditional_edges("agent", self._should_continue, {"continue": "tools", "end": END})
+        workflow.add_conditional_edges("tools", self._after_tools, {"continue": "agent", "summary": "summary", "end": END})
         workflow.add_edge("summary", END)
         return workflow.compile()
     
     def _should_continue(self, state: DocEditorState) -> str:
-        """
-        Decide whether to continue after agent node.
-        
-        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
+        """Decide whether to continue after agent node."""
         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")
+            logger.warning(f"Max iterations ({max_iterations}) reached - ending workflow")
             return "end"
         
         intermediate_steps = state.get("intermediate_steps", [])
@@ -92,53 +67,40 @@ class DocumentEditorAgent:
         
         last_message = intermediate_steps[-1]
         
-        # Check if last message has tool calls
         if hasattr(last_message, 'tool_calls') and last_message.tool_calls:
             tool_names = [tc['name'] for tc in last_message.tool_calls]
-            logger.info(f"🔧 Agent calling tools: {tool_names}")
+            logger.info(f"Agent calling tools: {tool_names}")
             return "continue"
         
-        # Check if attempt_completion was ever called successfully
-        attempt_completion_called = False
-        for msg in intermediate_steps:
-            if isinstance(msg, ToolMessage) and msg.name == "attempt_completion":
-                attempt_completion_called = True
-                break
+        # Check if attempt_completion was ever called
+        attempt_completion_called = any(
+            isinstance(msg, ToolMessage) and msg.name == "attempt_completion"
+            for msg in intermediate_steps
+        )
         
         if attempt_completion_called:
-            logger.info("✅ attempt_completion already called - ending workflow")
+            logger.info("attempt_completion already called - ending workflow")
             return "end"
         
-        # 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)")
+        logger.warning("Agent response without tool calls - forcing continue")
         return "continue"
     
     def _after_tools(self, state: DocEditorState) -> str:
-        """
-        Decide whether to continue after tools node.
-        
-        Returns:
-            "continue" if more iterations needed, "summary" if complete, "end" if max iterations reached
-        """
+        """Decide whether to continue after tools node."""
         intermediate_steps = state.get("intermediate_steps", [])
-    
         last_msg = intermediate_steps[-1]
-        if isinstance(last_msg, ToolMessage):
-            # Rule 1: If last tool was attempt_completion → go to summary
-            if last_msg.name == "attempt_completion":
-                logger.info("✅ attempt_completion called - generating summary")
-                return "summary"
         
-        # Rule 2: If beyond max_iterations → stop
+        if isinstance(last_msg, ToolMessage) and last_msg.name == "attempt_completion":
+            logger.info("attempt_completion called - generating summary")
+            return "summary"
+        
         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")
+            logger.warning(f"Max iterations ({max_iterations}) reached - ending workflow")
             return "end"
         
-        # Rule 3: Everything else → continue
         return "continue"
     
     async def _agent_node(self, state: DocEditorState) -> DocEditorState:
@@ -147,13 +109,23 @@ class DocumentEditorAgent:
         iteration_count = state.get("iteration_count", 0)
         max_iterations = state.get("max_iterations", 10)
         
-        logger.info(f"🔄 Agent iteration {iteration_count + 1}/{max_iterations}")
+        logger.info(f"Agent iteration {iteration_count + 1}/{max_iterations}")
         
-        # First iteration: add system prompt and user instruction
         if iteration_count == 0:
             intermediate_steps.append(SystemMessage(content=get_doc_editor_system_prompt()))
+            fake_tool_call_id = str(uuid.uuid4())
+            intermediate_steps.append(
+                AIMessage(content="", tool_calls=[{
+                    "id": fake_tool_call_id,
+                    "name": "view_current_document",
+                    "args": {}
+                }])
+            )
+            intermediate_steps.append(
+                ToolMessage(content=state['doc_text'], tool_call_id=fake_tool_call_id, name="view_current_document")
+            )
+            logger.info(f"🔍 Initial document provided via fake view_current_document ({len(state['doc_text'])}b)")
             
-            # Build context
             context_msg = ""
             conversation_history = state.get("conversation_history", [])
             doc_summaries = state.get("doc_summaries", [])
@@ -165,21 +137,16 @@ class DocumentEditorAgent:
             
             if doc_summaries:
                 context_msg += "\n\nDocument summaries:\n" + "\n".join(f"- {s}" for s in doc_summaries)
-            plan_formatted=f"""## EXECUTION PLAN
+            
+            plan_formatted = f"""## EXECUTION PLAN
 You have been provided with an execution plan. Follow this plan carefully to complete the task:
 {state['plan']}
 Use this plan as your guide for the editing steps to perform."""
-            # Add document and instruction
-            full_message = (
-                f"Current document (HTML):\n{state['doc_text']}\n\n"
-                f"{context_msg}\n\n"
-                f"Instruction: {state['user_instruction']}"
-                f"{plan_formatted}"
-            )
+            
+            full_message = f"{context_msg}\n\nInstruction: {state['user_instruction']}\n\n{plan_formatted}"
             intermediate_steps.append(HumanMessage(content=full_message))
-            logger.info(f"📚 Context: {len(conversation_history)} hist + {len(doc_summaries)} summaries")
+            logger.info(f"Context: {len(conversation_history)} hist + {len(doc_summaries)} summaries")
         
-        # Call LLM
         response = await self.llm_with_tools.ainvoke(intermediate_steps)
         intermediate_steps.append(response)
         
@@ -196,76 +163,58 @@ Use this plan as your guide for the editing steps to perform."""
         
         for tool_call in last_message.tool_calls:
             tool_name = tool_call['name']
-            
-            # Get the tool function directly from self.tools
             tool_func = next((t for t in self.tools if t.name == tool_name), None)
             
-            if tool_func:
-                args = tool_call['args'].copy()
-                
-                # 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)")
+            if not tool_func:
+                logger.warning(f"Tool function not found for {tool_name}")
+                continue
+            
+            args = tool_call['args'].copy()
+            
+            # Inject doc_text for editing tools
+            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}")
+            
+            if tool_name == "view_current_document":
+                logger.info(f"Viewing current document ({len(state['doc_text'])}b)")
+            
+            try:
+                result = await tool_func.ainvoke(args)
                 
-                try:
-                    # Call the LangChain tool with .ainvoke()
-                    result = await tool_func.ainvoke(args)
+                if result.get("ok") and "doc_text" in result:
+                    state["doc_text"] = result["doc_text"]
                     
-                    # Update doc_text if tool was successful
-                    if result.get("ok") and "doc_text" in result:
-                        state["doc_text"] = result["doc_text"]
+                    if tool_name in ["replace_html", "add_html", "delete_html"]:
+                        document_id = state.get("document_id")
+                        user_id = state.get("user_id")
                         
-                        # Push update to external endpoint if tool modified document successfully
-                        # Only for editing tools (replace_html, add_html, delete_html)
-                        if tool_name in ["replace_html", "add_html", "delete_html"]:
-                            document_id = state.get("document_id")
-                            user_id = state.get("user_id")
-                            
-                            if document_id and user_id:
-                                logger.info(f"📤 Pushing document update after successful {tool_name}...")
-                                # Async but await - continue editing regardless of success/failure
-                                await push_document_update(
-                                    document_id=document_id,
-                                    content=state["doc_text"],
-                                    user_id=user_id
-                                )
-                            else:
-                                logger.debug(f"ℹ️ No document_id/user_id, skipping update push")
-                    
-                    # Add result to conversation
-                    intermediate_steps.append(
-                        ToolMessage(
-                            content=str(result),
-                            tool_call_id=tool_call['id'],
-                            name=tool_name
-                        )
-                    )
-                except Exception as e:
-                    intermediate_steps.append(
-                        ToolMessage(
-                            content=f"Error: {str(e)}",
-                            tool_call_id=tool_call['id'],
-                            name=tool_name
-                        )
-                    )
-                    logger.error(f"❌ {tool_name} error: {str(e)}")
-            else:
-                logger.warning(f"⚠️ Tool function not found for {tool_name}")
+                        if document_id and user_id:
+                            logger.info(f"Pushing document update after successful {tool_name}...")
+                            await push_document_update(
+                                document_id=document_id,
+                                content=state["doc_text"],
+                                user_id=user_id
+                            )
+                        else:
+                            logger.debug("No document_id/user_id, skipping update push")
+                
+                intermediate_steps.append(
+                    ToolMessage(content=str(result), tool_call_id=tool_call['id'], name=tool_name)
+                )
+            except Exception as e:
+                intermediate_steps.append(
+                    ToolMessage(content=f"Error: {str(e)}", tool_call_id=tool_call['id'], name=tool_name)
+                )
+                logger.error(f"{tool_name} error: {str(e)}")
         
         state["intermediate_steps"] = intermediate_steps
         return state
     
     async def _summary_node(self, state: DocEditorState) -> DocEditorState:
         """Summary node: Generate a clean summary of all modifications."""
-        logger.info("📝 Generating modification summary...")
+        logger.info("Generating modification summary...")
         
-        # Build context for the summary - include the entire conversation
         summary_messages = [
             SystemMessage(content=get_summary_system_prompt()),
             HumanMessage(content=f"""
@@ -275,17 +224,15 @@ Full conversation history (including all tool calls and results):
 """, name="user")
         ]
         
-        # Add ALL messages from intermediate_steps (complete conversation)
         intermediate_steps = state.get("intermediate_steps", [])
         for msg in intermediate_steps:
             summary_messages.append(msg)
         
-        # Generate summary
         response = await self.llm.ainvoke(summary_messages)
         state["final_summary"] = response.content
         
-        logger.info("✅ Summary generated successfully")
-        logger.info(f"📋 Summary preview: {response.content[:200]}...")
+        logger.info("Summary generated successfully")
+        logger.info(f"Summary preview: {response.content}...")
         
         return state
     
@@ -314,37 +261,31 @@ Full conversation history (including all tool calls and results):
             user_id: Optional user ID for authentication
         
         Returns:
-            Dict with:
-                - doc_text: Modified document (HTML)
-                - message: Completion message or error description
-                - success: Boolean indicating success
-                - iteration_count: Number of iterations performed
+            Dict with doc_text, message, success, iteration_count, final_summary
         """
-        # Log initial state
         logger.info("=" * 80)
-        logger.info("🎯 DOCUMENT EDITOR AGENT STARTING")
+        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}")
+        logger.info(f"Initial document size: {len(doc_text)} bytes")
+        logger.info(f"Instruction: {user_instruction}{'...' 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 document_id:
-            logger.info(f"🆔 Document ID: {document_id} (live updates enabled)")
+            logger.info(f"Document ID: {document_id} (live updates enabled)")
         if user_id:
-            logger.info(f"👤 User ID: {user_id}")
+            logger.info(f"User ID: {user_id}")
         
         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]}...")
+            logger.info("Document summaries loaded:")
+            for i, summary in enumerate(doc_summaries, 1):
+                logger.info(f"  [{i}] {str(summary)}...")
             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)")
+            logger.info(f"Conversation history loaded ({len(conversation_history)} messages)")
         
-        # Initialize state
         initial_state = {
             "doc_text": doc_text,
             "doc_summaries": doc_summaries,
@@ -358,49 +299,42 @@ Full conversation history (including all tool calls and results):
             "user_id": user_id
         }
         
-        logger.info("🎯 Initial state prepared, starting workflow...")
+        logger.info("Initial state prepared, starting workflow...")
         
-        # Run workflow
         try:
-            logger.info("🔄 Invoking LangGraph workflow...")
+            logger.info("Invoking LangGraph workflow...")
             final_state = await self.workflow.ainvoke(initial_state)
             
-            # Prepare result
             final_summary = final_state.get("final_summary", "")
-            # Success if attempt_completion was called (which triggers summary)
-            attempt_completion_called = False
-            for msg in final_state.get("intermediate_steps", []):
-                if isinstance(msg, ToolMessage) and msg.name == "attempt_completion":
-                    attempt_completion_called = True
-                    break
+            attempt_completion_called = any(
+                isinstance(msg, ToolMessage) and msg.name == "attempt_completion"
+                for msg in final_state.get("intermediate_steps", [])
+            )
             success = attempt_completion_called
-            # Use final_summary as the main message for the frontend
-            message = final_summary 
+            message = final_summary
             
             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("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 ''}")
+            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}{'...' if len(message) > 100 else ''}")
             
-            # Log final document content
             logger.info("=" * 80)
-            logger.info("📄 FINAL DOCUMENT CONTENT")
+            logger.info("FINAL DOCUMENT CONTENT")
             logger.info("=" * 80)
             logger.info(final_state["doc_text"])
             logger.info("=" * 80)
             
-            # Log summary
             if final_summary:
                 logger.info("=" * 80)
-                logger.info("📋 MODIFICATION SUMMARY")
+                logger.info("MODIFICATION SUMMARY")
                 logger.info("=" * 80)
                 logger.info(final_summary)
                 logger.info("=" * 80)
@@ -408,7 +342,7 @@ Full conversation history (including all tool calls and results):
             if not success:
                 max_iters = final_state.get("max_iterations", 10)
                 if iteration_count >= max_iters:
-                    logger.warning(f"⚠️ Failed to complete editing within {max_iters} iterations")
+                    logger.warning(f"Failed to complete editing within {max_iters} iterations")
                     message = f"Failed to complete editing within {max_iters} iterations"
             
             return {
@@ -421,42 +355,33 @@ Full conversation history (including all tool calls and results):
         
         except Exception as e:
             logger.error("=" * 80)
-            logger.error("❌ DOCUMENT EDITING FAILED")
+            logger.error("DOCUMENT EDITING FAILED")
             logger.error("=" * 80)
-            logger.error(f"📍 Location: subagents/doc_editor.py:{traceback.extract_tb(e.__traceback__)[-1].lineno} (edit_document)")
-            logger.error("")
-            logger.error("📋 Input Parameters:")
-            logger.error(f"   - User Instruction: {user_instruction[:100] if len(user_instruction) > 100 else user_instruction}")
-            logger.error(f"   - Document Size: {len(doc_text):,} bytes")
+            logger.error(f"Location: subagents/doc_editor.py:{traceback.extract_tb(e.__traceback__)[-1].lineno}")
+            logger.error(f"Error type: {type(e).__name__}")
+            logger.error(f"Error message: {str(e)}")
+            logger.error(f"User Instruction: {user_instruction if len(user_instruction) > 100 else user_instruction}")
+            logger.error(f"Document Size: {len(doc_text):,} bytes")
             if document_id:
-                logger.error(f"   - Document ID: {document_id}")
+                logger.error(f"Document ID: {document_id}")
             if user_id:
-                logger.error(f"   - User ID: {user_id}")
-            logger.error(f"   - Max Iterations: {max_iterations}")
-            logger.error(f"   - Document Summaries: {len(doc_summaries)}")
-            logger.error(f"   - Conversation History: {len(conversation_history)} messages")
+                logger.error(f"User ID: {user_id}")
+            logger.error(f"Max Iterations: {max_iterations}")
+            logger.error(f"Document Summaries: {len(doc_summaries)}")
+            logger.error(f"Conversation History: {len(conversation_history)} messages")
             if plan:
-                logger.error(f"   - Plan: {plan[:200] if len(plan) > 200 else plan}")
-            logger.error("")
-            logger.error("🤖 LLM Configuration:")
-            logger.error(f"   - Main LLM: {type(self.llm).__name__}")
-            logger.error(f"   - Tool Calling LLM: {type(self.llm_tool_calling).__name__}")
-            logger.error(f"   - Tools Available: {len(self.tools)}")
-            logger.error(f"   - Tool Names: {', '.join([t.name for t in self.tools])}")
-            logger.error("")
-            logger.error("🔍 Exception Details:")
-            logger.error(f"   Type: {type(e).__name__}")
-            logger.error(f"   Message: {str(e)}")
-            logger.error("")
-            logger.error("📝 Full Traceback:")
-            logger.error(traceback.format_exc())
-            logger.error("")
-            logger.error("💾 Document Preview (first 200 chars):")
-            logger.error(f"   {doc_text[:200]}")
+                logger.error(f"Plan: {plan if len(plan) > 200 else plan}")
+            logger.error(f"Main LLM: {type(self.llm).__name__}")
+            logger.error(f"Tool Calling LLM: {type(self.llm_tool_calling).__name__}")
+            logger.error(f"Tools Available: {len(self.tools)}")
+            logger.error(f"Tool Names: {', '.join([t.name for t in self.tools])}")
+            logger.error(f"Traceback:\n{traceback.format_exc()}")
+            logger.error(f"Document Preview: {doc_text[:200]}")
             logger.error("=" * 80)
+            
             return {
-                "doc_text": doc_text,  # Return original on error
+                "doc_text": doc_text,
                 "message": f"Error during editing: {str(e)}",
                 "success": False,
                 "iteration_count": 0
-            }
+            }

utils/doc_editor_tools.py

@@ -235,25 +235,23 @@ async def delete_html(doc_text: str, search: str, expected_matches: int = 1) ->
 
 
 @tool
-async def inspect_document(doc_text: str = None) -> Dict[str, Any]:
+async def view_current_document() -> Dict[str, Any]:
     """
-    Return the current state of the document.
+    View the current state of the document being edited.
     
-    Use this tool to see the current document content in the message history.
-    This adds the document state to the conversation context so you can verify
-    previous edits and understand the current structure.
+    Use this tool to see the current document content after modifications.
+    This helps you verify previous edits and understand the current structure.
     
-    The document content will be automatically injected from the workflow state.
+    The document content is automatically provided by the workflow state.
     
     Returns:
         Dict with 'ok' (bool) and 'content' (str) containing the HTML document
     """
-    # 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")
+    # doc_text is injected by _tools_node in doc_editor.py
+    logger.info(f"  🔍 view_current_document")
     return {
         "ok": True,
-        "content": doc_text
+        "content": ""
     }