rebrand agents

agents/chat_agent.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""
+Flexible LangGraph agent for cyber-legal assistant
+Agent can call tools, process results, and decide to continue or answer
+"""
+
+import os
+import copy
+import logging
+from typing import Dict, Any, List, Optional
+from datetime import datetime
+from langgraph.graph import StateGraph, END
+from langchain_core.messages import HumanMessage, SystemMessage, AIMessage, ToolMessage
+
+logger = logging.getLogger(__name__)
+from agent_states.agent_state import AgentState
+from utils.utils_fn import PerformanceMonitor
+from utils.tools import tools, tools_for_client, tools_for_lawyer
+
+
+class CyberLegalAgent:
+    def __init__(self, llm, tools: List[Any] = tools, tools_facade: List[Any] = tools):
+        self.tools = tools
+        self.tools_facade = tools_facade
+        self.llm = llm
+        self.performance_monitor = PerformanceMonitor()
+        self.llm_with_tools = self.llm.bind_tools(self.tools_facade)
+        self.workflow = self._build_workflow()
+    
+    def _build_workflow(self) -> StateGraph:
+        workflow = StateGraph(AgentState)
+        workflow.add_node("agent", self._agent_node)
+        workflow.add_node("tools", self._tools_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", "end": END})
+        return workflow.compile()
+    
+    def _after_tools(self, state: AgentState) -> str:
+        intermediate_steps = state.get("intermediate_steps", [])
+        if not intermediate_steps:
+            return "continue"
+        
+        # Check if the last message is a ToolMessage from find_lawyers
+        last_message = intermediate_steps[-1]
+        if isinstance(last_message, ToolMessage):
+            if last_message.name == "_find_lawyers":
+                logger.info("🛑 find_lawyers tool completed - ending with tool output")
+                return "end"
+        
+        return "continue"
+    
+    def _should_continue(self, state: AgentState) -> str:
+        intermediate_steps = state.get("intermediate_steps", [])
+        if not intermediate_steps:
+            return "continue"
+        last_message = intermediate_steps[-1]
+        
+        if hasattr(last_message, 'tool_calls') and last_message.tool_calls:
+            print(last_message.tool_calls)
+            logger.info(f"🔧 Calling tools: {[tc['name'] for tc in last_message.tool_calls]}")
+            return "continue"
+        return "end"
+    
+    async def _agent_node(self, state: AgentState) -> AgentState:
+        intermediate_steps = state.get("intermediate_steps", [])
+        
+        if not intermediate_steps:
+            history = state.get("conversation_history", [])
+            # Use provided system prompt if available (not None), otherwise use the default
+            system_prompt_to_use = state.get("system_prompt")
+            jurisdiction = state.get("jurisdiction", "unknown")
+            # Deepcopy to avoid modifying the original prompt string
+            system_prompt_to_use = copy.deepcopy(system_prompt_to_use)
+            system_prompt_to_use = system_prompt_to_use.format(jurisdiction=jurisdiction)
+            logger.info(f"📍 Formatted system prompt with jurisdiction: {jurisdiction}")
+            
+            intermediate_steps.append(SystemMessage(content=system_prompt_to_use))
+            for msg in history:
+                if isinstance(msg, dict):
+                    if msg.get("role") == "user":
+                        intermediate_steps.append(HumanMessage(content=msg.get("content")))
+                    elif msg.get("role") == "assistant":
+                        intermediate_steps.append(AIMessage(content=msg.get("content")))
+            intermediate_steps.append(HumanMessage(content=state["user_query"]))
+        
+        response = await self.llm_with_tools.ainvoke(intermediate_steps)
+        intermediate_steps.append(response)
+        state["intermediate_steps"] = intermediate_steps
+        return state
+    
+    async def _tools_node(self, state: AgentState) -> AgentState:
+        intermediate_steps = state.get("intermediate_steps", [])
+        last_message = intermediate_steps[-1]
+        if not (hasattr(last_message, 'tool_calls') and last_message.tool_calls):
+            return state
+        for tool_call in last_message.tool_calls:
+            tool_func = next((t for t in self.tools if t.name == "_" + tool_call['name']), None)
+            if tool_func:
+                # Inject parameters from state into tool calls
+                args = tool_call['args'].copy()
+                
+                # Inject conversation_history for tools that need it
+                if tool_call['name'] in ["find_lawyers", "query_knowledge_graph", "message_lawyer"]:
+                    args["conversation_history"] = state.get("conversation_history", [])
+                    logger.info(f"📝 Injecting conversation_history to {tool_call['name']}: {len(args['conversation_history'])} messages")
+                
+                    # Inject jurisdiction for query_knowledge_graph tool
+                    if tool_call['name'] == "query_knowledge_graph":
+                        args["jurisdiction"] = state.get("jurisdiction")
+                        logger.info(f"🌍 Injecting jurisdiction: {args['jurisdiction']}")
+                    
+                    # Inject user_id for message_lawyer tool
+                    if tool_call['name'] == "message_lawyer":
+                        args["user_id"] = state.get("user_id")
+                        logger.info(f"👤 Injecting user_id: {args['user_id']}")
+                    
+                    # Inject user_id for retrieve_lawyer_document tool
+                    if tool_call['name'] == "retrieve_lawyer_document":
+                        args["user_id"] = state.get("user_id")
+                        logger.info(f"📄 Injecting user_id for retrieve_lawyer_document: {args['user_id']}")
+                    
+                    # Inject user_id for create_draft_document tool
+                    if tool_call['name'] == "create_draft_document":
+                        args["user_id"] = state.get("user_id")
+                        logger.info(f"📝 Injecting user_id for create_draft_document: {args['user_id']}")
+                    
+                    tool_call['name']="_" + tool_call['name']
+                
+                result = await tool_func.ainvoke(args)
+                logger.info(f"🔧 Tool {tool_call} returned: {result}")
+                intermediate_steps.append(ToolMessage(content=str(result), tool_call_id=tool_call['id'], name=tool_call['name']))
+        
+        state["intermediate_steps"] = intermediate_steps
+        return state
+    
+    async def process_query(self, user_query: str, user_id: Optional[str] = None, jurisdiction: str = "Romania", conversation_history: Optional[List[Dict[str, str]]] = None, system_prompt: Optional[str] = None) -> Dict[str, Any]:
+        initial_state = {
+            "user_query": user_query,
+            "user_id": user_id,
+            "conversation_history": conversation_history or [],
+            "intermediate_steps": [],
+            "relevant_documents": [],
+            "query_timestamp": datetime.now().isoformat(),
+            "processing_time": None,
+            "jurisdiction": jurisdiction,
+            "system_prompt": system_prompt
+        }
+        self.performance_monitor.reset()
+        
+        final_state = await self.workflow.ainvoke(initial_state)
+        intermediate_steps = final_state.get("intermediate_steps", [])
+        final_response = intermediate_steps[-1].content
+        
+        return {
+            "response": final_response or "I apologize, but I couldn't generate a response.",
+            "processing_time": sum(self.performance_monitor.get_metrics().values()),
+            "references": final_state.get("relevant_documents", []),
+            "timestamp": final_state.get("query_timestamp")
+        }

{subagents → agents}/doc_editor.py

@@ -11,11 +11,12 @@ 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_html, add_html, delete_html, view_current_document, attempt_completion
+from utils.tools import (
+    tools_for_doc_editor_facade as doc_editor_tools_facade,
+    tools_for_doc_editor as doc_editor_tools
 )
 from prompts.doc_editor import get_doc_editor_system_prompt, get_summary_system_prompt
-from utils.update_notifier import push_document_update
+from utils.utils_fn import push_document_update
 
 logger = logging.getLogger(__name__)
 
@@ -23,21 +24,25 @@ logger = logging.getLogger(__name__)
 class DocumentEditorAgent:
     """Agent for editing HTML documents using Cline-like iterative approach."""
     
-    def __init__(self, llm, llm_tool_calling):
+    def __init__(self, llm, llm_tool_calling, tools=doc_editor_tools, tools_facade=doc_editor_tools_facade):
         """
         Initialize the document editor agent.
         
         Args:
             llm: LLM principal pour la génération du résumé final
             llm_tool_calling: LLM pour les tool calls
+            tools: Liste des tools d'implémentation (avec doc_text injecté)
+            tools_facade: Liste des tools façades (pour le LLM)
         """
         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")
+        self.tools = tools
+        self.tools_facade = tools_facade
+        self.llm_with_tools = self.llm_tool_calling.bind_tools(self.tools_facade, 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")
         logger.info(f"📝 Using {type(llm).__name__} for summary generation")
+        logger.info(f"🛠️ Tools loaded: {len(self.tools_facade)} facade, {len(self.tools)} implementation")
         self.workflow = self._build_workflow()
     
     def _build_workflow(self) -> StateGraph:

{subagents → agents}/pdf_analyzer.py

@@ -9,7 +9,6 @@ import pypdf
 from typing import Optional
 from langgraph.graph import StateGraph, END
 from langchain_openai import ChatOpenAI
-from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_core.messages import HumanMessage, SystemMessage
 from mistralai import Mistral
 

docs/CREATE_DRAFT_DOCUMENT.md

@@ -0,0 +1,183 @@
+# create_draft_document Tool
+
+## Overview
+
+The `create_draft_document` tool allows users (both clients and lawyers) to create and save new document drafts directly to their "My Documents" storage in Supabase.
+
+## Tool Specifications
+
+### Facade Version (User-facing)
+
+```python
+@tool
+async def create_draft_document(
+    title: str,
+    content: str,
+    path: str
+) -> str
+```
+
+**Parameters:**
+- `title` (str): Document title (e.g., "Contract de bail", "Note juridique")
+- `content` (str): Document content in HTML format (e.g., "<h1>Title</h1><p>Content...</p>")
+- `path` (str): Folder path where to save the document
+  - Empty string `""` → root folder of My Documents
+  - `"Contracts/"` → ./Contracts/title.pdf
+  - `"Drafts/Legal/"` → ./Drafts/Legal/title.pdf
+
+**Returns:**
+- Confirmation message with document path and success status
+
+### Real Implementation (With user_id injection)
+
+```python
+@tool
+async def _create_draft_document(
+    user_id: str,
+    title: str,
+    content: str,
+    path: str
+) -> str
+```
+
+**Additional Parameter:**
+- `user_id` (str): User UUID (automatically injected by the agent from state)
+
+## Usage Examples
+
+### Example 1: Save to root folder
+```python
+create_draft_document(
+    title="Mon document",
+    content="<h1>Document</h1><p>Contenu...</p>",
+    path=""
+)
+# Saves as: ./Mon document.pdf
+```
+
+### Example 2: Save to Contracts folder
+```python
+create_draft_document(
+    title="Contract de bail",
+    content="<h1>Contrat de bail</h1><p>Ce contrat est conclu entre...</p>",
+    path="Contracts/"
+)
+# Saves as: ./Contracts/Contract de bail.pdf
+```
+
+### Example 3: Save to nested folder
+```python
+create_draft_document(
+    title="Note juridique",
+    content="<h1>Note</h1><p>Contenu juridique...</p>",
+    path="Drafts/Legal/"
+)
+# Saves as: ./Drafts/Legal/Note juridique.pdf
+```
+
+## Path Normalization Rules
+
+The tool automatically normalizes the path:
+
+1. Removes leading `./` if present
+2. Ensures trailing `/` if path is provided
+3. Adds `.pdf` extension automatically
+4. Builds full path as `./{path}{title}.pdf`
+
+| Input Path | Normalized Output |
+|------------|-------------------|
+| `"Contracts/"` | `"./Contracts/"` |
+| `"Contracts"` | `"./Contracts/"` |
+| `""` | `"./"` |
+| `"./Contracts/"` | `"./Contracts/"` |
+| `"Drafts/Legal/"` | `"./Drafts/Legal/"` |
+
+## API Integration
+
+### Supabase Endpoint
+
+- **URL:** `{SUPABASE_BASE_URL}/create-document-from-html`
+- **Method:** POST
+- **Headers:**
+  - `x-api-key: <CYBERLGL_API_KEY>`
+
+### Request Body
+
+```json
+{
+  "userId": "uuid-de-l-utilisateur",
+  "html": "<h1>Document Title</h1><p>Content...</p>",
+  "path": "./Contracts/Document Title.pdf"
+}
+```
+
+### Response Handling
+
+The tool handles different HTTP status codes:
+
+- `200`: Success - Document saved
+- `400`: Bad request - Returns error details
+- `401`: Authentication failed - Invalid API key
+- `403`: Access denied - No permission
+- `500`: Server error
+
+## Integration with Agents
+
+### Toolsets
+
+The tool is integrated into:
+
+- **Client Tools:** `tools_for_client_facade` and `tools_for_client`
+- **Lawyer Tools:** `tools_for_lawyer_facade` and `tools_for_lawyer`
+
+### Parameter Injection
+
+The `CyberLegalAgent` automatically injects `user_id` from the agent state when calling `_create_draft_document`:
+
+```python
+# In agents/chat_agent.py
+if tool_call['name'] == "create_draft_document":
+    args["user_id"] = state.get("user_id")
+    logger.info(f"📝 Injecting user_id for create_draft_document: {args['user_id']}")
+```
+
+## Configuration Requirements
+
+The following environment variables must be set:
+
+- `SUPABASE_BASE_URL`: Base URL for Supabase functions
+- `CYBERLGL_API_KEY`: API key for authentication
+
+## Error Handling
+
+The tool includes comprehensive error handling:
+
+- Timeout errors (30s timeout)
+- Connection errors
+- JSON parsing errors
+- HTTP status code errors
+- Configuration errors (missing environment variables)
+
+## Testing
+
+A test file is available at `tests/test_create_draft_document.py` which tests:
+
+1. Facade functionality
+2. Real implementation with various path formats
+3. Path normalization logic
+
+## Use Cases
+
+Users should use this tool when they want to:
+
+- Create a new document draft
+- Save a generated document
+- Store a document in their document library
+- Organize documents in specific folders
+
+## Notes
+
+- The `.pdf` extension is added automatically
+- The path normalization is handled transparently
+- The tool is available to both clients and lawyers
+- The user_id is automatically injected and not exposed to users