agent-framework-lib 0.8.2.post2__tar.gz → 0.8.3__tar.gz

{agent_framework_lib-0.8.2.post2 → agent_framework_lib-0.8.3}/MANIFEST.in

@@ -11,6 +11,9 @@ include docs/*.md
 # Include type information
 include agent_framework/py.typed
 
+# Include PowerPoint templates embedded with the powerpoint skill
+recursive-include agent_framework/skills/builtin/skills/powerpoint/templates *.pptx
+
 # Include HTML templates and static files from the main package
 include agent_framework/test_app.html
 include agent_framework/*.html

{agent_framework_lib-0.8.2.post2/agent_framework_lib.egg-info → agent_framework_lib-0.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-framework-lib
-Version: 0.8.2.post2
+Version: 0.8.3
 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.2.post2 → agent_framework_lib-0.8.3}/agent_framework/__init__.py

@@ -32,7 +32,7 @@ Example Usage:
     create_basic_agent_server(MyAgent, port=8000)
     ```
 
-Version: 0.8.2
+Version: 0.8.3
 Author: Cinco AI Team
 License: MIT
 """
@@ -88,7 +88,7 @@ def _auto_setup_dependencies() -> None:
 # Track if auto-setup has been done
 _AUTO_SETUP_DONE = False
 
-__version__ = "0.8.2"
+__version__ = "0.8.3"
 __author__ = "Cinco AI Team"
 __license__ = "MIT"
 __email__ = "sebastian@cinco.ai"

{agent_framework_lib-0.8.2.post2 → agent_framework_lib-0.8.3}/agent_framework/core/base_agent.py

@@ -596,7 +596,16 @@ class BaseAgent(SkillsMixin, MemoryMixin, AgentInterface):
         try:
             from ..tools.shell_tool import ShellTool
 
-            tools.append(ShellTool(default_timeout=120).get_tool_function())
+            shell_tool = ShellTool(default_timeout=120)
+            # Inject session context so that AGENT_USER_ID / AGENT_SESSION_ID are
+            # propagated to subprocesses (register_to_storage / create_and_register).
+            # Without this, generated files are uploaded without session_id and
+            # never appear in the session's file list.
+            shell_tool.set_context(
+                user_id=getattr(self, "_current_user_id", None),
+                session_id=getattr(self, "_current_session_id", None),
+            )
+            tools.append(shell_tool.get_tool_function())
         except Exception as e:
             logger.warning(f"Could not create ShellTool: {e}")
 
@@ -666,17 +675,38 @@ class BaseAgent(SkillsMixin, MemoryMixin, AgentInterface):
             except Exception as e:
                 logger.warning(f"Failed to add memory tools: {e}")
 
+        # Deduplicate tools by name (Anthropic rejects duplicate tool names)
+        seen_names: set[str] = set()
+        unique_tools: list = []
+        for tool in tools:
+            meta = getattr(tool, "metadata", None)
+            if meta and hasattr(meta, "name"):
+                name = meta.name
+            else:
+                name = getattr(tool, "__name__", None) or getattr(tool, "name", None) or str(id(tool))
+            if name not in seen_names:
+                seen_names.add(name)
+                unique_tools.append(tool)
+            else:
+                logger.debug(f"⚠️ Skipping duplicate tool '{name}' for agent {self.agent_id}")
+
+        if len(unique_tools) < len(tools):
+            logger.info(
+                f"🔄 Deduplicated tools for agent {self.agent_id}: "
+                f"{len(tools)} → {len(unique_tools)}"
+            )
+
         # 5. Add subagent spawn tool if configured
         try:
             spawn_tool = self._create_subagent_spawn_tool()
             if spawn_tool is not None:
-                tools = tools + [spawn_tool.get_tool_function()]
+                unique_tools = unique_tools + [spawn_tool.get_tool_function()]
                 logger.info(f"🤖 Added SubagentSpawnTool to agent {self.agent_id}")
         except Exception as e:
             logger.warning(f"Failed to create SubagentSpawnTool: {e}")
 
-        logger.debug(f"📊 Total tools for agent {self.agent_id}: {len(tools)}")
-        return tools
+        logger.debug(f"📊 Total tools for agent {self.agent_id}: {len(unique_tools)}")
+        return unique_tools
 
     async def _async_ensure_agent_built(self):
         """Ensure agent is built (asynchronous)."""
@@ -794,6 +824,48 @@ class BaseAgent(SkillsMixin, MemoryMixin, AgentInterface):
             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 recall_lessons, format_lessons_for_prompt
+                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}"
+
             prompt = self._session_system_prompt or ""
             if "{{native_user_preferences}}" in prompt:
                 self._session_system_prompt = prompt.replace(
@@ -1038,7 +1110,10 @@ class BaseAgent(SkillsMixin, MemoryMixin, AgentInterface):
                     )
 
                     if success:
-                        logger.debug(f"Auto-stored interaction for user {user_id}")
+                        logger.info(
+                            "[MEMORY_STORE] Auto-stored interaction for user=%s "
+                            "(response_len=%d)", user_id, len(response_text)
+                        )
                     else:
                         logger.warning(f"Failed to auto-store interaction for user {user_id}")
             except Exception as e:
@@ -1430,7 +1505,10 @@ class BaseAgent(SkillsMixin, MemoryMixin, AgentInterface):
                     )
 
                     if success:
-                        logger.debug(f"Auto-stored streaming interaction for user {user_id}")
+                        logger.info(
+                            "[MEMORY_STORE] Auto-stored streaming interaction for user=%s "
+                            "(response_len=%d)", user_id, len(final_text)
+                        )
                     else:
                         logger.warning(
                             f"Failed to auto-store streaming interaction for user {user_id}"

{agent_framework_lib-0.8.2.post2 → agent_framework_lib-0.8.3}/agent_framework/memory/__init__.py

@@ -88,6 +88,29 @@ from .tools import (
     get_memory_tools_descriptions,
 )
 
+# Work Pattern Intelligence
+from .work_patterns import (
+    RequestIntent,
+    RequestComplexity,
+    WorkPatternEntry,
+    WorkProfile,
+    WorkPatternTracker,
+    WorkPatternAnalyzer,
+    classify_intent,
+    classify_complexity,
+    detect_domains,
+)
+
+# Implicit Feedback
+from .implicit_feedback import (
+    FeedbackSignal,
+    FeedbackEntry,
+    ImplicitFeedbackTracker,
+    FeedbackProfile,
+    FeedbackProfileBuilder,
+    analyze_feedback,
+)
+
 
 __all__ = [
     # Configuration
@@ -114,6 +137,25 @@ __all__ = [
     # Providers
     "MemoriProvider",
     "GraphitiProvider",
+
+    # Work Pattern Intelligence
+    "RequestIntent",
+    "RequestComplexity",
+    "WorkPatternEntry",
+    "WorkProfile",
+    "WorkPatternTracker",
+    "WorkPatternAnalyzer",
+    "classify_intent",
+    "classify_complexity",
+    "detect_domains",
+
+    # Implicit Feedback
+    "FeedbackSignal",
+    "FeedbackEntry",
+    "ImplicitFeedbackTracker",
+    "FeedbackProfile",
+    "FeedbackProfileBuilder",
+    "analyze_feedback",
 ]
 
 __version__ = "0.3.5.1"

{agent_framework_lib-0.8.2.post2 → agent_framework_lib-0.8.3}/agent_framework/memory/agent_mixin.py

@@ -239,9 +239,9 @@ class MemoryMixin:
     ) -> bool:
         """
         Store an interaction for memory extraction.
-
-        Call this after generating a response to store the interaction.
-
+        
+        Also tracks work patterns and implicit feedback automatically.
+        
         Args:
             user_id: User identifier
             session_id: Session identifier
@@ -258,11 +258,13 @@ class MemoryMixin:
         if not self._memory_manager:
             return False
 
+        agent_id = getattr(self, 'agent_id', 'agent')
+
         try:
-            return await self._memory_manager.store_interaction(
+            result = await self._memory_manager.store_interaction(
                 user_id=user_id,
                 session_id=session_id,
-                agent_id=getattr(self, "agent_id", "agent"),
+                agent_id=agent_id,
                 user_message=user_message,
                 agent_response=agent_response,
                 metadata=metadata,
@@ -271,6 +273,55 @@ class MemoryMixin:
             logger.error(f"Error storing memory interaction: {e}")
             return False
 
+        # Track work pattern + implicit feedback in background (never blocks)
+        provider = self._memory_manager.primary
+        if provider:
+            # Work pattern tracking
+            try:
+                from .work_patterns import WorkPatternTracker
+                tracker = WorkPatternTracker(provider)
+                entry = await tracker.track(
+                    user_id=user_id,
+                    message=user_message,
+                    agent_id=agent_id,
+                    session_id=session_id,
+                )
+                logger.info(
+                    "[WORK_PATTERN] user=%s intent=%s complexity=%s domains=%s",
+                    user_id, entry.intent.value, entry.complexity.value,
+                    ",".join(entry.domains) or "none",
+                )
+            except Exception as e:
+                logger.debug(f"Work pattern tracking skipped: {e}")
+
+            # Implicit feedback: analyze user message against previous response
+            try:
+                from .implicit_feedback import ImplicitFeedbackTracker
+                if not hasattr(self, '_feedback_tracker'):
+                    self._feedback_tracker = ImplicitFeedbackTracker(provider)
+
+                # Analyze current user message against last agent response
+                fb_entry = await self._feedback_tracker.analyze_and_store(
+                    user_id=user_id,
+                    user_message=user_message,
+                    agent_id=agent_id,
+                    session_id=session_id,
+                )
+                if fb_entry:
+                    logger.info(
+                        "[IMPLICIT_FEEDBACK] user=%s signal=%s confidence=%.2f "
+                        "correction_type=%s topic_changed=%s",
+                        user_id, fb_entry.signal.value, fb_entry.confidence,
+                        fb_entry.correction_type or "n/a", fb_entry.topic_changed,
+                    )
+
+                # Record this agent response for next iteration
+                self._feedback_tracker.record_agent_response(user_id, agent_response)
+            except Exception as e:
+                logger.debug(f"Implicit feedback tracking skipped: {e}")
+
+        return result
+
     async def clear_user_memory(self, user_id: str) -> bool:
         """
         Clear all memories for a user.