le sputains de noms sont pas bons kevin!

agent_states/actors_merger.py

@@ -7,3 +7,4 @@ class ActorsMergerState(TypedDict):
     existing_actors: List[Dict[str, Any]]
     messages: List[Any]
     completed: bool
+    modified_actor_names: List[str]

agents/actors_merger.py

@@ -1,11 +1,10 @@
-
 import os
 import httpx
 import json
 import logging
 import asyncio
 from typing import TypedDict, List, Dict, Any
-from agent_states.actors_merger_state import ActorResolutionState
+from agent_states.actors_merger import ActorsMergerState
 from langgraph.graph import StateGraph, END
 from langchain_core.messages import HumanMessage, SystemMessage, ToolMessage
 from prompts.actors_merger import SYSTEM_PROMPT,ACTOR_MERGER_PROMPT
@@ -20,7 +19,7 @@ class ActorsMergerAgent:
         self.workflow = self._build_workflow()
 
     def _build_workflow(self):
-        workflow = StateGraph(ActorResolutionState)
+        workflow = StateGraph(ActorsMergerState)
         workflow.add_node("reason", self._reason)
         workflow.add_node("run_tools", self._run_tools)
 
@@ -38,10 +37,10 @@ class ActorsMergerAgent:
 
         return workflow.compile()
 
-    def _should_continue(self, state: ActorResolutionState) -> str:
+    def _should_continue(self, state: ActorsMergerState) -> str:
         return "done" if state["completed"] else "continue"
 
-    async def _reason(self, state: ActorResolutionState) -> ActorResolutionState:
+    async def _reason(self, state: ActorsMergerState) -> ActorsMergerState:
         if not state["messages"]:
             state["messages"] = [
                 SystemMessage(content=SYSTEM_PROMPT),
@@ -50,10 +49,10 @@ class ActorsMergerAgent:
                 {ACTOR_MERGER_PROMPT}
 
                 NEW_ACTORS:
-                {json.dumps(new_extractions, indent=2)}
+                {json.dumps(state["new_extractions"], indent=2)}
 
                 EXISTING_ACTORS:
-                {json.dumps(existing_actors, indent=2)}
+                {json.dumps(state["existing_actors"], indent=2)}
                 """
                 ),
             ]
@@ -62,7 +61,7 @@ class ActorsMergerAgent:
         state["messages"].append(response)
         return state
 
-    async def _run_tools(self, state: ActorResolutionState) -> ActorResolutionState:
+    async def _run_tools(self, state: ActorsMergerState) -> ActorsMergerState:
         last_message = state["messages"][-1]
         tool_calls = getattr(last_message, "tool_calls", []) or []
 
@@ -73,6 +72,11 @@ class ActorsMergerAgent:
             if name == "add_actors":
                 actors = args.get("actors", [])
                 state["existing_actors"].extend(actors)
+                # Track added actor names
+                for actor in actors:
+                    actor_name = actor.get("name")
+                    if actor_name and actor_name not in state["modified_actor_names"]:
+                        state["modified_actor_names"].append(actor_name)
                 result = {"ok": True, "added": len(actors)}
 
             elif name == "modify_actors":
@@ -86,6 +90,10 @@ class ActorsMergerAgent:
 
                     for actor in state["existing_actors"]:
                         if actor.get("name") == target_name:
+                            # Track modified actor name (using original name before change)
+                            if target_name not in state["modified_actor_names"]:
+                                state["modified_actor_names"].append(target_name)
+                            
                             if mod.get("name"):
                                 actor["name"] = mod["name"]
 
@@ -159,8 +167,8 @@ class ActorsMergerAgent:
             logger.error(f"❌ Fetch existing actors failed: {e}")
         return []
 
-    async def _update_actors(self, user_id: str, actors: List[Dict[str, Any]]) -> bool:
-        """Update actors to Supabase"""
+    async def _update_changed_actors(self, user_id: str, actors: List[Dict[str, Any]]) -> bool:
+        """Update changed actors to Supabase (only modified or newly added actors)"""
         try:
             base_url = os.getenv("SUPABASE_BASE_URL")
             if not base_url:
@@ -185,18 +193,19 @@ class ActorsMergerAgent:
         new_extractions: List[Dict[str, Any]],
         existing_actors: List[Dict[str, Any]]
     ) -> Dict[str, Any]:
-        initial_state: ActorResolutionState = {
+        initial_state: ActorsMergerState = {
             "new_extractions": new_extractions,
             "existing_actors": existing_actors,
             "messages": [],
             "completed": False,
+            "modified_actor_names": [],
         }
 
         final_state = await self.workflow.ainvoke(initial_state)
 
         return {
             "existing_actors": final_state["existing_actors"],
-            "completed": final_state["completed"],
+            "modified_actor_names": final_state["modified_actor_names"],
         }
 
     async def process_actors_async(self, actors_md: str, user_id: str):
@@ -212,29 +221,46 @@ class ActorsMergerAgent:
         try:
             logger.info(f"🔄 Starting actors processing for user {user_id}")
             
-            # Step 1: Fetch existing actors from Supabase
+            # Step 1: Parse markdown to actor list
+            logger.info("📝 Parsing actors from markdown...")
+            new_extractions = self._parse_actors(actors_md)
+            logger.info(f"✅ Parsed {len(new_extractions)} new actors")
+            
+            # Step 2: Fetch existing actors from Supabase
             logger.info("📥 Fetching existing actors from Supabase...")
             existing_actors = await self._fetch_existing_actors(user_id)
             logger.info(f"✅ Fetched {len(existing_actors)} existing actors")
             
-            # Step 2: Merge using LLM reasoning
+            # Step 3: Merge using LLM reasoning
             logger.info("🤖 Merging actors using LLM...")
             result = await self.resolve(
-                new_extractions=actors_md,
+                new_extractions=new_extractions,
                 existing_actors=existing_actors
             )
             merged_actors = result["existing_actors"]
-            logger.info(f"✅ Merged into {len(merged_actors)} actors")
+            modified_actor_names = result["modified_actor_names"]
+            logger.info(f"✅ Merged into {len(merged_actors)} actors, {len(modified_actor_names)} modified")
             
-            # Step 3: Update actors to Supabase
-            logger.info("📤 Updating actors to Supabase...")
-            success = await self._update_actors(user_id, merged_actors)
-            if success:
-                logger.info("✅ Actors processing completed successfully")
+            # Step 4: Filter only modified actors
+            if modified_actor_names:
+                logger.info(f"🔍 Filtering {len(modified_actor_names)} modified actors...")
+                changed_actors = [
+                    actor for actor in merged_actors
+                    if actor.get("name") in modified_actor_names
+                ]
+                logger.info(f"✅ Found {len(changed_actors)} changed actors")
+                
+                # Step 5: Update only changed actors to Supabase
+                logger.info("📤 Updating changed actors to Supabase...")
+                success = await self._update_changed_actors(user_id, changed_actors)
+                if success:
+                    logger.info("✅ Actors processing completed successfully")
+                else:
+                    logger.error("❌ Failed to update actors to Supabase")
             else:
-                logger.error("❌ Failed to update actors to Supabase")
+                logger.info("✅ No actors were modified, skipping update")
                 
         except Exception as e:
             logger.error(f"❌ Error in process_actors_async: {e}")
             import traceback
-            logger.error(f"🔍 Traceback: {traceback.format_exc()}")
+            logger.error(f"🔍 Traceback: {traceback.format_exc()}")

agents/pdf_analyzer.py

@@ -187,12 +187,22 @@ class PDFAnalyzerAgent:
         logger.info("=" * 80)
         logger.info("✅ Actors extracted")
         
-        # asyncio.create_task(
-        #     self.actors_merger.process_actors_async(
-        #         actors_md=state["actors"],
-        #         user_id=state["user_id"]
-        #     )
-        # )
+        # Launch actors merger asynchronously in the background
+        if self.actors_merger and state.get("user_id"):
+            logger.info("🚀 Launching actors merger in background...")
+            asyncio.create_task(
+                self.actors_merger.process_actors_async(
+                    actors_md=state["actors"],
+                    user_id=state["user_id"]
+                )
+            )
+            logger.info("✅ Actors merger task created (running in background)")
+        else:
+            if not self.actors_merger:
+                logger.warning("⚠️ Actors merger not initialized, skipping")
+            if not state.get("user_id"):
+                logger.warning("⚠️ user_id not provided, skipping actors merger")
+        
         return state
     
     async def _extract_key_details(self, state: PDFAnalyzerState) -> PDFAnalyzerState: