agent-framework-lib 0.8.4.post5__tar.gz → 0.8.5__tar.gz

{agent_framework_lib-0.8.4.post5/agent_framework_lib.egg-info → agent_framework_lib-0.8.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-framework-lib
-Version: 0.8.4.post5
+Version: 0.8.5
 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.4.post5 → agent_framework_lib-0.8.5}/agent_framework/__init__.py

@@ -89,7 +89,7 @@ def _auto_setup_dependencies() -> None:
 # Track if auto-setup has been done
 _AUTO_SETUP_DONE = False
 
-__version__ = "0.8.4"
+__version__ = "0.8.5"
 __author__ = "Cinco AI Team"
 __license__ = "MIT"
 __email__ = "sebastian@cinco.ai"

{agent_framework_lib-0.8.4.post5 → agent_framework_lib-0.8.5}/agent_framework/core/base_agent.py

@@ -31,6 +31,8 @@ if TYPE_CHECKING:
     from ..subagents.executor import SubagentExecutor
     from ..subagents.message_queue import SessionMessageQueue
     from ..subagents.spawn_tool import SubagentSpawnTool
+    from ..tools.shell_tool import ShellTool
+    from ..workspace.models import Workspace
 
 from ..monitoring.streaming_latency_tracer import get_streaming_latency_tracer
 from ..utils.special_blocks import parse_special_blocks_from_text
@@ -248,6 +250,13 @@ class BaseAgent(SkillsMixin, MemoryMixin, AgentInterface):
         self._current_spawn_depth: int = 0
         self._file_storage_session_id: str | None = None
 
+        # Workspace context (optional, injected by workspace router)
+        self._workspace_secrets: dict[str, str] = {}
+        self._workspace_context: Workspace | None = None
+        self._live_shell_tool: ShellTool | None = None
+        self._pending_workspace_update: Workspace | None = None
+        self._pending_workspace_apply: Any | None = None
+
         # Initialize parent classes (including SkillsMixin and MemoryMixin if available)
         super().__init__()
 
@@ -351,6 +360,22 @@ class BaseAgent(SkillsMixin, MemoryMixin, AgentInterface):
         """
         return None
 
+    def set_workspace_metadata(self, workspace: Workspace | None) -> None:
+        """Store workspace context + secrets on the agent.
+
+        Updates the live ``ShellTool`` (if any) immediately so the next
+        ``shell_exec`` call sees fresh secrets without an agent rebuild.
+        Does NOT trigger a rebuild on its own — callers control when the
+        system prompt is refreshed (see ``configure_session``).
+        """
+        self._workspace_context = workspace
+        self._workspace_secrets = workspace.secret_entries() if workspace else {}
+        if self._live_shell_tool is not None:
+            try:
+                self._live_shell_tool.set_workspace_secrets(self._workspace_secrets)
+            except Exception as e:
+                logger.warning(f"Could not propagate workspace secrets to live ShellTool: {e}")
+
     def set_subagent_executor(self, executor: SubagentExecutor | None) -> None:
         """Inject or remove the shared SubagentExecutor.
 
@@ -607,6 +632,8 @@ class BaseAgent(SkillsMixin, MemoryMixin, AgentInterface):
                 user_id=getattr(self, "_current_user_id", None),
                 session_id=getattr(self, "_current_session_id", None),
             )
+            shell_tool.set_workspace_secrets(self._workspace_secrets)
+            self._live_shell_tool = shell_tool
             tools.append(shell_tool.get_tool_function())
         except Exception as e:
             logger.warning(f"Could not create ShellTool: {e}")
@@ -1239,6 +1266,20 @@ class BaseAgent(SkillsMixin, MemoryMixin, AgentInterface):
             yield StructuredAgentOutput(response_text="Input query cannot be empty.", parts=[])
             return
 
+        # Apply any workspace update that was deferred because a previous
+        # turn was streaming. Runs before _async_ensure_agent_built() so the
+        # rebuild (if needed) sees the fresh context. Last-writer-wins.
+        pending_apply = self._pending_workspace_apply
+        if pending_apply is not None:
+            self._pending_workspace_apply = None
+            self._pending_workspace_update = None
+            try:
+                result = pending_apply()
+                if hasattr(result, "__await__"):
+                    await result
+            except Exception as e:
+                logger.warning(f"Pending workspace update failed to apply: {e}")
+
         # Get tracer for instrumentation
         tracer = get_streaming_latency_tracer()
 

{agent_framework_lib-0.8.4.post5 → agent_framework_lib-0.8.5}/agent_framework/core/implementation_validator.py

@@ -312,7 +312,7 @@ class AgentImplementationValidator:
                 hints = get_type_hints(run_agent) if hasattr(run_agent, "__annotations__") else {}
             except NameError:
                 hints = {}
-            return_hint = hints.get("return", None)
+            return_hint = hints.get("return")
             if return_hint is None:
                 self.report.add_warning(
                     "signature",

{agent_framework_lib-0.8.4.post5 → agent_framework_lib-0.8.5}/agent_framework/memory/hypothesis_engine.py

@@ -37,6 +37,7 @@ from datetime import datetime
 from enum import Enum
 from typing import Any
 
+
 logger = logging.getLogger(__name__)
 
 
@@ -216,7 +217,7 @@ class Hypothesis:
         }
 
     @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "Hypothesis":
+    def from_dict(cls, data: dict[str, Any]) -> Hypothesis:
         """Désérialise depuis un dictionnaire.
 
         Args:
@@ -516,14 +517,16 @@ class ConversationalPairAnalyzer:
 
             followup_nature = self.classify_followup_nature(current_preview)
 
-            pairs.append(ConversationalPair(
-                agent_response_preview=prev_preview,
-                user_followup_preview=current_preview,
-                initial_intent=initial_intent,
-                followup_nature=followup_nature,
-                resource_context=resource_context,
-                timestamp=timestamp,
-            ))
+            pairs.append(
+                ConversationalPair(
+                    agent_response_preview=prev_preview,
+                    user_followup_preview=current_preview,
+                    initial_intent=initial_intent,
+                    followup_nature=followup_nature,
+                    resource_context=resource_context,
+                    timestamp=timestamp,
+                )
+            )
 
         # --- Source 2: implicit_feedback entries ---
         for entry in feedback_entries:
@@ -538,14 +541,16 @@ class ConversationalPairAnalyzer:
 
             followup_nature = self.classify_followup_nature(user_preview)
 
-            pairs.append(ConversationalPair(
-                agent_response_preview=agent_preview,
-                user_followup_preview=user_preview,
-                initial_intent=initial_intent,
-                followup_nature=followup_nature,
-                resource_context=None,
-                timestamp=timestamp,
-            ))
+            pairs.append(
+                ConversationalPair(
+                    agent_response_preview=agent_preview,
+                    user_followup_preview=user_preview,
+                    initial_intent=initial_intent,
+                    followup_nature=followup_nature,
+                    resource_context=None,
+                    timestamp=timestamp,
+                )
+            )
 
         # Sort by timestamp (oldest first)
         pairs.sort(key=lambda p: p.timestamp)
@@ -573,11 +578,26 @@ class ConversationalPairAnalyzer:
             return FollowupNature.COMPLEMENT_CONTEXTUEL
 
         scores: list[tuple[FollowupNature, int]] = [
-            (FollowupNature.SUPPORT_VISUEL, _count_pattern_matches(user_followup, _VISUAL_SUPPORT_PATTERNS)),
-            (FollowupNature.APPROFONDISSEMENT, _count_pattern_matches(user_followup, _DEEPENING_PATTERNS)),
-            (FollowupNature.REFORMATAGE, _count_pattern_matches(user_followup, _REFORMATTING_PATTERNS)),
-            (FollowupNature.ILLUSTRATION_CONCRETE, _count_pattern_matches(user_followup, _CONCRETE_ILLUSTRATION_PATTERNS)),
-            (FollowupNature.COMPLEMENT_CONTEXTUEL, _count_pattern_matches(user_followup, _CONTEXTUAL_COMPLEMENT_PATTERNS)),
+            (
+                FollowupNature.SUPPORT_VISUEL,
+                _count_pattern_matches(user_followup, _VISUAL_SUPPORT_PATTERNS),
+            ),
+            (
+                FollowupNature.APPROFONDISSEMENT,
+                _count_pattern_matches(user_followup, _DEEPENING_PATTERNS),
+            ),
+            (
+                FollowupNature.REFORMATAGE,
+                _count_pattern_matches(user_followup, _REFORMATTING_PATTERNS),
+            ),
+            (
+                FollowupNature.ILLUSTRATION_CONCRETE,
+                _count_pattern_matches(user_followup, _CONCRETE_ILLUSTRATION_PATTERNS),
+            ),
+            (
+                FollowupNature.COMPLEMENT_CONTEXTUEL,
+                _count_pattern_matches(user_followup, _CONTEXTUAL_COMPLEMENT_PATTERNS),
+            ),
         ]
 
         # Pick the nature with the highest score
@@ -648,17 +668,18 @@ class ConversationalPairAnalyzer:
 
             # Collect up to 3 representative examples
             examples: list[tuple[str, str]] = [
-                (p.agent_response_preview, p.user_followup_preview)
-                for p in group_pairs[:3]
+                (p.agent_response_preview, p.user_followup_preview) for p in group_pairs[:3]
             ]
 
-            recurring_needs.append({
-                "initial_intent": intent,
-                "followup_nature": nature,
-                "occurrences": len(group_pairs),
-                "resource_contexts": resource_contexts,
-                "examples": examples,
-            })
+            recurring_needs.append(
+                {
+                    "initial_intent": intent,
+                    "followup_nature": nature,
+                    "occurrences": len(group_pairs),
+                    "resource_contexts": resource_contexts,
+                    "examples": examples,
+                }
+            )
 
         # Sort by occurrence count descending
         recurring_needs.sort(key=lambda x: x["occurrences"], reverse=True)
@@ -757,12 +778,9 @@ class HypothesisEngine:
         # ------------------------------------------------------------------
 
         # 1a. Preferences via PersonalizationAnalyzer (Requirement 3.1)
-        preferences: dict[str, Any] = {}
         try:
             pa = UserPersonalizationAnalyzer(self._provider)
-            preferences = await pa.analyze_user_preferences(
-                user_id=user_id, agent_id=agent_id
-            )
+            _ = await pa.analyze_user_preferences(user_id=user_id, agent_id=agent_id)
         except Exception as exc:
             logger.warning("Failed to read preferences for user %s: %s", user_id, exc)
 
@@ -780,9 +798,7 @@ class HypothesisEngine:
         resource_profile = ResourceProfile()
         try:
             wpt = WorkPatternTracker(self._provider)
-            rp_dict = await wpt.get_resource_profile(
-                user_id=user_id, agent_id=agent_id
-            )
+            rp_dict = await wpt.get_resource_profile(user_id=user_id, agent_id=agent_id)
             resource_profile = ResourceProfile.from_dict(rp_dict)
         except Exception as exc:
             logger.warning("Failed to read resource profile for user %s: %s", user_id, exc)
@@ -800,7 +816,7 @@ class HypothesisEngine:
                 ),
                 limit=200,
             )
-            for fact in (wp_context.facts if wp_context else []):
+            for fact in wp_context.facts if wp_context else []:
                 meta = getattr(fact, "metadata", None)
                 if isinstance(meta, dict) and meta.get("type") == "work_pattern":
                     # Apply temporal windowing (Requirement 10.2)
@@ -829,7 +845,7 @@ class HypothesisEngine:
                 ),
                 limit=200,
             )
-            for fact in (fb_context.facts if fb_context else []):
+            for fact in fb_context.facts if fb_context else []:
                 meta = getattr(fact, "metadata", None)
                 if isinstance(meta, dict) and meta.get("type") == "implicit_feedback":
                     # Apply temporal windowing (Requirement 10.2)
@@ -987,14 +1003,16 @@ class HypothesisEngine:
             hypothesis.last_updated = now
 
             # Record decay event in history
-            hypothesis.history.append({
-                "event": "temporal_decay",
-                "timestamp": now.isoformat(),
-                "old_confidence": old_confidence,
-                "new_confidence": hypothesis.confidence,
-                "decay_amount": 0.1,
-                "inactive_days": (now - hypothesis.last_updated).days,
-            })
+            hypothesis.history.append(
+                {
+                    "event": "temporal_decay",
+                    "timestamp": now.isoformat(),
+                    "old_confidence": old_confidence,
+                    "new_confidence": hypothesis.confidence,
+                    "decay_amount": 0.1,
+                    "inactive_days": (now - hypothesis.last_updated).days,
+                }
+            )
 
             # Invalidate if confidence drops below 0.05
             if hypothesis.confidence < 0.05:
@@ -1002,12 +1020,14 @@ class HypothesisEngine:
                 hypothesis.invalidation_reason = (
                     f"Confiance tombée à {hypothesis.confidence:.4f} par décroissance temporelle"
                 )
-                hypothesis.history.append({
-                    "event": "invalidation",
-                    "timestamp": now.isoformat(),
-                    "reason": hypothesis.invalidation_reason,
-                    "confidence_at_invalidation": hypothesis.confidence,
-                })
+                hypothesis.history.append(
+                    {
+                        "event": "invalidation",
+                        "timestamp": now.isoformat(),
+                        "reason": hypothesis.invalidation_reason,
+                        "confidence_at_invalidation": hypothesis.confidence,
+                    }
+                )
 
             await self._persist_hypothesis(hypothesis, user_id, agent_id)
             decayed.append(hypothesis)
@@ -1123,9 +1143,7 @@ class HypothesisEngine:
         ]
 
         # Total interactions for learning rate computation
-        total_interactions = sum(
-            h.validation_count + h.correction_count for h in active
-        )
+        total_interactions = sum(h.validation_count + h.correction_count for h in active)
 
         lr_state = self.compute_learning_rate(total_interactions, avg_confidence)
 
@@ -1137,12 +1155,8 @@ class HypothesisEngine:
             "top_3_hypotheses": top_3,
             "learning_rate_state": {
                 "phase": lr_state.phase,
-                "current_validation_increment": round(
-                    lr_state.current_validation_increment, 4
-                ),
-                "current_correction_decrement": round(
-                    lr_state.current_correction_decrement, 4
-                ),
+                "current_validation_increment": round(lr_state.current_validation_increment, 4),
+                "current_correction_decrement": round(lr_state.current_correction_decrement, 4),
                 "total_interactions": lr_state.total_interactions,
                 "avg_confidence": round(lr_state.avg_confidence, 4),
             },
@@ -1200,9 +1214,7 @@ class HypothesisEngine:
             try:
                 hypothesis = Hypothesis.from_dict(metadata)
             except (ValueError, TypeError) as exc:
-                logger.warning(
-                    "Failed to deserialize hypothesis %s: %s", hypothesis_id, exc
-                )
+                logger.warning("Failed to deserialize hypothesis %s: %s", hypothesis_id, exc)
                 continue
 
             # Apply status filter
@@ -1285,13 +1297,11 @@ class HypothesisEngine:
         alpha = 1.0 / (1.0 + math.exp(-sigmoid_input))
 
         # --- Interpolate rates ---
-        current_validation_increment = (
-            cfg.initial_validation_increment
-            + alpha * (cfg.mature_validation_increment - cfg.initial_validation_increment)
+        current_validation_increment = cfg.initial_validation_increment + alpha * (
+            cfg.mature_validation_increment - cfg.initial_validation_increment
         )
-        current_correction_decrement = (
-            cfg.initial_correction_decrement
-            + alpha * (cfg.mature_correction_decrement - cfg.initial_correction_decrement)
+        current_correction_decrement = cfg.initial_correction_decrement + alpha * (
+            cfg.mature_correction_decrement - cfg.initial_correction_decrement
         )
 
         # --- Phase label ---
@@ -1437,8 +1447,8 @@ class HypothesisEngine:
             # Check if resource profile adds converging evidence
             if resource_profile is not None:
                 freq_resources = getattr(resource_profile, "frequent_resources", {})
-                for rtype, items in freq_resources.items():
-                    for res_name, res_count in items:
+                for _rtype, items in freq_resources.items():
+                    for _res_name, res_count in items:
                         if res_count >= 5:
                             factors.append("resource_frequency")
                             break
@@ -1537,8 +1547,8 @@ class HypothesisEngine:
                 trigger_context = f"{trigger_context} impliquant {resource_mention}"
 
             # Map followup nature to implicit need and proposed action
-            implicit_need, proposed_action, category = (
-                self._followup_nature_to_components(nature, resource_mention)
+            implicit_need, proposed_action, category = self._followup_nature_to_components(
+                nature, resource_mention
             )
 
             if not implicit_need or not proposed_action:
@@ -1604,11 +1614,7 @@ class HypothesisEngine:
             correction_counts[correction_type] += 1
 
             # Collect context for richer hypothesis formulation
-            context = (
-                entry.get("user_followup_preview")
-                or entry.get("message_preview")
-                or ""
-            )
+            context = entry.get("user_followup_preview") or entry.get("message_preview") or ""
             if context:
                 correction_contexts[correction_type].append(context)
 
@@ -1664,9 +1670,7 @@ class HypothesisEngine:
         if resource_profile is None:
             return hypotheses
 
-        associations: list = getattr(
-            resource_profile, "resource_output_associations", []
-        )
+        associations: list = getattr(resource_profile, "resource_output_associations", [])
 
         for assoc in associations:
             if not isinstance(assoc, (list, tuple)) or len(assoc) < 3:
@@ -2069,18 +2073,18 @@ class HypothesisEngine:
         # Reactivation of invalidated hypothesis (Requirement 5.6)
         if hypothesis.status == HypothesisStatus.INVALIDATED:
             # Reactivate at 50% of standard initial confidence
-            initial_confidence = self._compute_initial_confidence(
-                len(hypothesis.trigger_factors)
-            )
+            initial_confidence = self._compute_initial_confidence(len(hypothesis.trigger_factors))
             hypothesis.confidence = initial_confidence * 0.5
             hypothesis.status = HypothesisStatus.ACTIVE
             hypothesis.invalidation_reason = None
             hypothesis.invalidation_context = None
-            hypothesis.history.append({
-                "event": "reactivation",
-                "timestamp": now.isoformat(),
-                "new_confidence": hypothesis.confidence,
-            })
+            hypothesis.history.append(
+                {
+                    "event": "reactivation",
+                    "timestamp": now.isoformat(),
+                    "new_confidence": hypothesis.confidence,
+                }
+            )
             hypothesis.last_updated = now
             await self._persist_hypothesis(hypothesis, user_id, agent_id)
             return hypothesis
@@ -2093,19 +2097,23 @@ class HypothesisEngine:
 
         # Increment confidence (Requirement 5.1)
         old_confidence = hypothesis.confidence
-        hypothesis.confidence = min(1.0, hypothesis.confidence + lr_state.current_validation_increment)
+        hypothesis.confidence = min(
+            1.0, hypothesis.confidence + lr_state.current_validation_increment
+        )
         hypothesis.validation_count += 1
         hypothesis.last_updated = now
 
         # Record event in history (Requirement 5.5)
-        hypothesis.history.append({
-            "event": "validation",
-            "timestamp": now.isoformat(),
-            "old_confidence": old_confidence,
-            "new_confidence": hypothesis.confidence,
-            "increment": lr_state.current_validation_increment,
-            "learning_rate_phase": lr_state.phase,
-        })
+        hypothesis.history.append(
+            {
+                "event": "validation",
+                "timestamp": now.isoformat(),
+                "old_confidence": old_confidence,
+                "new_confidence": hypothesis.confidence,
+                "increment": lr_state.current_validation_increment,
+                "learning_rate_phase": lr_state.phase,
+            }
+        )
 
         await self._persist_hypothesis(hypothesis, user_id, agent_id)
         return hypothesis
@@ -2156,7 +2164,9 @@ class HypothesisEngine:
 
         # Decrement confidence (Requirement 5.2)
         old_confidence = hypothesis.confidence
-        hypothesis.confidence = max(0.0, hypothesis.confidence - lr_state.current_correction_decrement)
+        hypothesis.confidence = max(
+            0.0, hypothesis.confidence - lr_state.current_correction_decrement
+        )
         hypothesis.correction_count += 1
         hypothesis.last_updated = now
 
@@ -2181,12 +2191,14 @@ class HypothesisEngine:
                 f"de type '{correction_type}'"
             )
             hypothesis.invalidation_context = correction_context
-            hypothesis.history.append({
-                "event": "invalidation",
-                "timestamp": now.isoformat(),
-                "reason": hypothesis.invalidation_reason,
-                "confidence_at_invalidation": hypothesis.confidence,
-            })
+            hypothesis.history.append(
+                {
+                    "event": "invalidation",
+                    "timestamp": now.isoformat(),
+                    "reason": hypothesis.invalidation_reason,
+                    "confidence_at_invalidation": hypothesis.confidence,
+                }
+            )
 
         await self._persist_hypothesis(hypothesis, user_id, agent_id)
         return hypothesis
@@ -2271,13 +2283,15 @@ class HypothesisEngine:
                 target.trigger_factors.append(factor)
                 seen.add(factor)
 
-        target.history.append({
-            "event": "merge",
-            "timestamp": now.isoformat(),
-            "merged_hypothesis_id": source.hypothesis_id,
-            "merged_confidence": source.confidence,
-            "resulting_confidence": target.confidence,
-        })
+        target.history.append(
+            {
+                "event": "merge",
+                "timestamp": now.isoformat(),
+                "merged_hypothesis_id": source.hypothesis_id,
+                "merged_confidence": source.confidence,
+                "resulting_confidence": target.confidence,
+            }
+        )
 
         return target
 
@@ -2518,8 +2532,7 @@ class WorkPatternBuilder:
 
         # --- Pass 1: Group by project context --------------------------------
         project_hypotheses = [
-            h for h in hypotheses
-            if h.category == HypothesisCategory.PROJET_CONTEXTE
+            h for h in hypotheses if h.category == HypothesisCategory.PROJET_CONTEXTE
         ]
         if project_hypotheses:
             project_groups = self._cluster_by_trigger_overlap(project_hypotheses)
@@ -2578,9 +2591,7 @@ class WorkPatternBuilder:
         # Multiple hypotheses — synthesise a workflow directive.
         # Sort by confidence descending so the most confident hypothesis
         # drives the primary description.
-        sorted_group = sorted(
-            hypothesis_group, key=lambda h: h.confidence, reverse=True
-        )
+        sorted_group = sorted(hypothesis_group, key=lambda h: h.confidence, reverse=True)
 
         primary = sorted_group[0]
 
@@ -2599,10 +2610,7 @@ class WorkPatternBuilder:
 
         # Build a combined workflow directive
         actions_str = " ; ".join(additional_actions)
-        return (
-            f"{primary.description} "
-            f"De plus : {actions_str}."
-        )
+        return f"{primary.description} " f"De plus : {actions_str}."
 
     # -- Internal helpers ----------------------------------------------------
 
@@ -2621,13 +2629,51 @@ class WorkPatternBuilder:
             Set of lower-cased meaningful tokens.
         """
         _STOP_WORDS: set[str] = {
-            "les", "des", "une", "que", "qui", "est", "dans",
-            "pour", "par", "sur", "avec", "son", "ses", "aux",
-            "pas", "mais", "sont", "ont", "été", "fait", "quand",
-            "après", "avant", "entre", "cette", "ces", "tout",
-            "tous", "elle", "lui", "leur", "nous", "vous",
-            "the", "and", "for", "with", "from", "this", "that",
-            "when", "after", "before", "user", "utilisateur",
+            "les",
+            "des",
+            "une",
+            "que",
+            "qui",
+            "est",
+            "dans",
+            "pour",
+            "par",
+            "sur",
+            "avec",
+            "son",
+            "ses",
+            "aux",
+            "pas",
+            "mais",
+            "sont",
+            "ont",
+            "été",
+            "fait",
+            "quand",
+            "après",
+            "avant",
+            "entre",
+            "cette",
+            "ces",
+            "tout",
+            "tous",
+            "elle",
+            "lui",
+            "leur",
+            "nous",
+            "vous",
+            "the",
+            "and",
+            "for",
+            "with",
+            "from",
+            "this",
+            "that",
+            "when",
+            "after",
+            "before",
+            "user",
+            "utilisateur",
         }
         tokens = set(re.findall(r"[a-zA-Z0-9_./\\-]{3,}", trigger_context.lower()))
         return tokens - _STOP_WORDS