agent-framework-lib 0.8.7.post3__tar.gz → 0.8.7.post4__tar.gz

{agent_framework_lib-0.8.7.post3/agent_framework_lib.egg-info → agent_framework_lib-0.8.7.post4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-framework-lib
-Version: 0.8.7.post3
+Version: 0.8.7.post4
 Summary: A comprehensive Python framework for building and serving conversational AI agents with FastAPI
 Author-email: Sebastian Pavel <sebastian@cinco.ai>, Elliott Girard <elliott.girard@icloud.com>
 Maintainer-email: Sebastian Pavel <sebastian@cinco.ai>

{agent_framework_lib-0.8.7.post3 → agent_framework_lib-0.8.7.post4}/agent_framework/core/base_agent.py

@@ -15,6 +15,7 @@ Subclasses must implement all abstract methods to provide framework-specific fun
 
 from __future__ import annotations
 
+import asyncio
 import json
 import logging
 import os
@@ -849,13 +850,15 @@ class BaseAgent(SkillsMixin, MemoryMixin, AgentInterface):
             user_id = session_configuration.get("user_id", "default_user")
             provider = self._memory_manager.primary
 
-            context = await provider.recall(
-                user_id=user_id,
-                agent_id=self.agent_id,
-                query="préférences style réponse utilisateur",
-                limit=20,
+            # Les trois lectures mémoire (préférences, work patterns, response
+            # lessons) sont indépendantes et toutes I/O Graphiti : on les lance
+            # en parallèle pour réduire la latence du préprocessing. Le prompt
+            # résultant est identique au chemin séquentiel précédent.
+            facts, work_profile_block, lessons_block = await asyncio.gather(
+                self._recall_user_preferences(provider, user_id),
+                self._build_work_profile_block(provider, user_id),
+                self._build_lessons_block(provider, user_id),
             )
-            facts = context.facts if context else []
 
             if not facts:
                 # Replace placeholder with empty string if present
@@ -867,48 +870,6 @@ class BaseAgent(SkillsMixin, MemoryMixin, AgentInterface):
                 return
 
             fact_lines = "\n".join(f"- {f.content}" for f in facts if f.content)
-            preference_block = f"[User Preferences]\n{fact_lines}"
-
-            # --- Work Pattern directives ---
-            work_profile_block = ""
-            try:
-                from ..memory.work_patterns import WorkPatternAnalyzer
-
-                wp_analyzer = WorkPatternAnalyzer(provider)
-                work_profile = await wp_analyzer.build_profile(
-                    user_id=user_id,
-                    agent_id=self.agent_id,
-                    min_entries=3,
-                )
-                if work_profile.total_interactions >= 3:
-                    directives = wp_analyzer.build_agent_directives(work_profile)
-                    if directives:
-                        work_profile_block = "\n\n[Directives de travail]\n" f"{directives}"
-                        logger.info(
-                            "Work pattern directives injected for user=%s: %d interactions",
-                            user_id,
-                            work_profile.total_interactions,
-                        )
-            except Exception as e:
-                logger.debug("Work pattern injection skipped: %s", e)
-
-            # --- Response Lessons (the key part) ---
-            lessons_block = ""
-            try:
-                from ..memory.response_lessons import format_lessons_for_prompt, recall_lessons
-
-                lessons = await recall_lessons(provider, user_id, self.agent_id, limit=10)
-                if lessons:
-                    formatted = format_lessons_for_prompt(lessons)
-                    if formatted:
-                        lessons_block = f"\n\n[Leçons apprises — compléments à inclure automatiquement]\n{formatted}"
-                        logger.info(
-                            "Response lessons injected for user=%s: %d lessons",
-                            user_id,
-                            len(lessons),
-                        )
-            except Exception as e:
-                logger.debug("Response lessons injection skipped: %s", e)
 
             preference_block = (
                 f"[User Preferences]\n{fact_lines}{work_profile_block}{lessons_block}"
@@ -927,6 +888,86 @@ class BaseAgent(SkillsMixin, MemoryMixin, AgentInterface):
         except Exception as e:
             logger.warning("Personalization injection skipped: %s", e)
 
+    async def _recall_user_preferences(self, provider: Any, user_id: str) -> list[Any]:
+        """Recall les facts de préférences utilisateur depuis la mémoire.
+
+        Args:
+            provider: Provider mémoire primaire.
+            user_id: Identifiant utilisateur.
+
+        Returns:
+            Liste de facts de préférences (vide si aucun).
+        """
+        context = await provider.recall(
+            user_id=user_id,
+            agent_id=self.agent_id,
+            query="préférences style réponse utilisateur",
+            limit=20,
+        )
+        return context.facts if context else []
+
+    async def _build_work_profile_block(self, provider: Any, user_id: str) -> str:
+        """Construit le bloc de directives de travail depuis les work patterns.
+
+        Args:
+            provider: Provider mémoire primaire.
+            user_id: Identifiant utilisateur.
+
+        Returns:
+            Bloc texte à injecter (vide si pas assez de données ou en cas d'échec).
+        """
+        try:
+            from ..memory.work_patterns import WorkPatternAnalyzer
+
+            wp_analyzer = WorkPatternAnalyzer(provider)
+            work_profile = await wp_analyzer.build_profile(
+                user_id=user_id,
+                agent_id=self.agent_id,
+                min_entries=3,
+            )
+            if work_profile.total_interactions >= 3:
+                directives = wp_analyzer.build_agent_directives(work_profile)
+                if directives:
+                    logger.info(
+                        "Work pattern directives injected for user=%s: %d interactions",
+                        user_id,
+                        work_profile.total_interactions,
+                    )
+                    return "\n\n[Directives de travail]\n" f"{directives}"
+        except Exception as e:
+            logger.debug("Work pattern injection skipped: %s", e)
+        return ""
+
+    async def _build_lessons_block(self, provider: Any, user_id: str) -> str:
+        """Construit le bloc de leçons apprises depuis les response lessons.
+
+        Args:
+            provider: Provider mémoire primaire.
+            user_id: Identifiant utilisateur.
+
+        Returns:
+            Bloc texte à injecter (vide si aucune leçon ou en cas d'échec).
+        """
+        try:
+            from ..memory.response_lessons import format_lessons_for_prompt, recall_lessons
+
+            lessons = await recall_lessons(provider, user_id, self.agent_id, limit=10)
+            if lessons:
+                formatted = format_lessons_for_prompt(lessons)
+                if formatted:
+                    logger.info(
+                        "Response lessons injected for user=%s: %d lessons",
+                        user_id,
+                        len(lessons),
+                    )
+                    return (
+                        "\n\n[Leçons apprises — compléments à inclure automatiquement]\n"
+                        f"{formatted}"
+                    )
+        except Exception as e:
+            logger.debug("Response lessons injection skipped: %s", e)
+        return ""
+
     def _has_shell_tool(self) -> bool:
         """Check whether a shell tool is available."""
         return self._live_shell_tool is not None

{agent_framework_lib-0.8.7.post3 → agent_framework_lib-0.8.7.post4}/agent_framework/core/model_router.py

@@ -140,7 +140,6 @@ class ModelRouter:
     DEFAULT_STANDARD_MODELS: list[str] = [
         "claude-sonnet-4-6",
         "gpt-5.4-mini",
-        "claude-haiku-4-5-20251001",
         "gemini-2.5-flash",
         "gemini-3-flash-preview",
     ]

{agent_framework_lib-0.8.7.post3 → agent_framework_lib-0.8.7.post4}/agent_framework/web/server.py

@@ -9,7 +9,7 @@ import os
 import secrets  # Ensure secrets is imported for compare_digest
 import time  # Added for postprocessing span timing
 import uuid
-from collections.abc import AsyncGenerator
+from collections.abc import AsyncGenerator, Coroutine
 from contextlib import asynccontextmanager, suppress
 from datetime import datetime, timezone
 from pathlib import Path
@@ -51,6 +51,98 @@ logger = logging.getLogger(__name__)
 # Module-level state for response lesson tracking (persists across requests)
 _lesson_trackers: dict = {}
 
+# Registre des tâches de post-traitement fire-and-forget (work patterns,
+# response lessons). asyncio ne conserve qu'une référence faible aux tâches
+# créées via create_task : sans ce set, le ramasse-miettes peut les annuler
+# avant la fin. Le set est drainé au shutdown du lifespan.
+_background_tasks: set[asyncio.Task] = set()
+
+# Délai max d'attente des tâches background au shutdown (secondes).
+_BACKGROUND_TASKS_DRAIN_TIMEOUT: float = 40.0
+
+
+def _spawn_background_task(coro: Coroutine[Any, Any, Any]) -> asyncio.Task:
+    """Planifie une coroutine en tâche de fond et la garde référencée.
+
+    La tâche est ajoutée à `_background_tasks` puis retirée à sa complétion,
+    ce qui empêche son annulation prématurée par le GC et permet un drain
+    propre au shutdown.
+
+    Args:
+        coro: La coroutine à exécuter en arrière-plan.
+
+    Returns:
+        La tâche asyncio planifiée.
+    """
+    task = asyncio.create_task(coro)
+    _background_tasks.add(task)
+    task.add_done_callback(_background_tasks.discard)
+    return task
+
+
+async def _track_work_patterns_and_lessons(
+    *,
+    provider: Any,
+    user_id: str,
+    user_query: str,
+    response_text: str,
+    agent_id: str,
+    session_id: str,
+) -> None:
+    """Capture les work patterns et response lessons en arrière-plan.
+
+    Extrait du chemin de streaming pour ne pas bloquer l'émission du message
+    final et de l'événement `done` : ces écritures (Graphiti `add_episode`)
+    peuvent prendre plusieurs secondes. Les données sont agrégées et
+    différer une entrée n'altère pas leur justesse.
+
+    Toutes les exceptions sont absorbées : un échec de tracking ne doit
+    jamais impacter la conversation.
+
+    Args:
+        provider: Provider mémoire primaire.
+        user_id: Identifiant utilisateur.
+        user_query: Message de l'utilisateur.
+        response_text: Réponse de l'agent.
+        agent_id: Identifiant de l'agent.
+        session_id: Identifiant de session.
+    """
+    try:
+        from agent_framework.memory.work_patterns import WorkPatternTracker
+
+        wp_tracker = WorkPatternTracker(provider)
+        wp_entry = await wp_tracker.track(
+            user_id=user_id,
+            message=user_query,
+            agent_id=agent_id,
+            session_id=session_id,
+        )
+        logger.info(
+            "[WORK_PATTERN] user=%s intent=%s complexity=%s domains=%s",
+            user_id,
+            wp_entry.intent.value,
+            wp_entry.complexity.value,
+            ",".join(wp_entry.domains) or "none",
+        )
+
+        from agent_framework.memory.response_lessons import ResponseLessonTracker
+
+        if agent_id not in _lesson_trackers:
+            _lesson_trackers[agent_id] = ResponseLessonTracker(provider)
+        lesson_tracker = _lesson_trackers[agent_id]
+
+        # Vérifie si le message courant est un suivi de la réponse précédente
+        await lesson_tracker.check_and_store(
+            user_id=user_id,
+            user_message=user_query,
+            agent_id=agent_id,
+        )
+
+        # Enregistre cette réponse pour la prochaine itération
+        lesson_tracker.record_response(user_id, response_text)
+    except Exception as e:
+        logger.debug("[WORK_PATTERN] Tracking skipped: %s", e)
+
 # Capability set for subagent wiring
 from ..capabilities.resolver import CapabilitySet
 from ..core.agent_interface import (
@@ -932,6 +1024,27 @@ async def lifespan(app: FastAPI):
         except Exception as e:
             logger.warning(f"[A2A] Error closing task provider: {e}")
 
+    # Drain des tâches de post-traitement fire-and-forget (work patterns,
+    # response lessons) pour ne pas les perdre à l'arrêt.
+    if _background_tasks:
+        pending_count = len(_background_tasks)
+        logger.info(f"[BACKGROUND] Waiting for {pending_count} background tasks...")
+        try:
+            await asyncio.wait_for(
+                asyncio.gather(*_background_tasks, return_exceptions=True),
+                timeout=_BACKGROUND_TASKS_DRAIN_TIMEOUT,
+            )
+            logger.debug("[BACKGROUND] All background tasks completed")
+        except asyncio.TimeoutError:
+            remaining = len(_background_tasks)
+            logger.warning(
+                f"[BACKGROUND] Timeout after {_BACKGROUND_TASKS_DRAIN_TIMEOUT}s, "
+                f"{remaining} background tasks may be incomplete; cancelling."
+            )
+            for task in list(_background_tasks):
+                if not task.done():
+                    task.cancel()
+
 
 # < --- Lifespan Event Handler ---
 
@@ -2769,6 +2882,9 @@ async def handle_stream_endpoint(
                     )
 
                     # --- Work Pattern & Implicit Feedback & Response Lessons tracking ---
+                    # Exécuté en tâche de fond : ces écritures Graphiti peuvent
+                    # prendre plusieurs secondes et ne doivent pas retarder
+                    # l'émission du message final ni de l'événement `done`.
                     try:
                         if (
                             hasattr(agent_instance, "_memory_manager")
@@ -2785,46 +2901,18 @@ async def handle_stream_endpoint(
                                 elif hasattr(processed_input, "query") and processed_input.query:
                                     user_query = processed_input.query
 
-                                # Work pattern tracking
-                                from agent_framework.memory.work_patterns import WorkPatternTracker
-
-                                wp_tracker = WorkPatternTracker(provider)
-                                wp_entry = await wp_tracker.track(
-                                    user_id=user_id,
-                                    message=user_query,
-                                    agent_id=agent_identity.agent_id,
-                                    session_id=session_id,
-                                )
-                                logger.info(
-                                    "[WORK_PATTERN] user=%s intent=%s complexity=%s domains=%s",
-                                    user_id,
-                                    wp_entry.intent.value,
-                                    wp_entry.complexity.value,
-                                    ",".join(wp_entry.domains) or "none",
+                                _spawn_background_task(
+                                    _track_work_patterns_and_lessons(
+                                        provider=provider,
+                                        user_id=user_id,
+                                        user_query=user_query,
+                                        response_text=response_text,
+                                        agent_id=agent_identity.agent_id,
+                                        session_id=session_id,
+                                    )
                                 )
-
-                                # Response lesson tracking
-                                from agent_framework.memory.response_lessons import (
-                                    ResponseLessonTracker,
-                                )
-
-                                tracker_key = agent_identity.agent_id
-                                if tracker_key not in _lesson_trackers:
-                                    _lesson_trackers[tracker_key] = ResponseLessonTracker(provider)
-                                lesson_tracker = _lesson_trackers[tracker_key]
-
-                                # Check if current message is a follow-up to previous response
-                                await lesson_tracker.check_and_store(
-                                    user_id=user_id,
-                                    user_message=user_query,
-                                    agent_id=agent_identity.agent_id,
-                                )
-
-                                # Record this response for next iteration
-                                lesson_tracker.record_response(user_id, response_text)
-
                     except Exception as e:
-                        logger.debug("[WORK_PATTERN] Tracking skipped: %s", e)
+                        logger.debug("[WORK_PATTERN] Tracking scheduling skipped: %s", e)
                 else:
                     logger.error(
                         f"[PERSIST] FAILED to persist agent response in {persist_duration_ms:.2f}ms "

{agent_framework_lib-0.8.7.post3 → agent_framework_lib-0.8.7.post4/agent_framework_lib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-framework-lib
-Version: 0.8.7.post3
+Version: 0.8.7.post4
 Summary: A comprehensive Python framework for building and serving conversational AI agents with FastAPI
 Author-email: Sebastian Pavel <sebastian@cinco.ai>, Elliott Girard <elliott.girard@icloud.com>
 Maintainer-email: Sebastian Pavel <sebastian@cinco.ai>

{agent_framework_lib-0.8.7.post3 → agent_framework_lib-0.8.7.post4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agent-framework-lib"
-version = "0.8.7post3"
+version = "0.8.7post4"
 description = "A comprehensive Python framework for building and serving conversational AI agents with FastAPI"
 readme = {file = "README.md", content-type = "text/markdown"}
 license = {text = "MIT"}