Initial commit: add .gitignore and README

fusionagi/agents/reasoner.py

@@ -0,0 +1,226 @@
+"""Reasoner agent: reasons over step/subgoal + context; outputs recommendation via CoT.
+
+The Reasoner agent:
+- Processes reason_request messages
+- Uses Chain-of-Thought or Tree-of-Thought reasoning
+- Integrates with WorkingMemory for context
+- Records reasoning traces to EpisodicMemory
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, TYPE_CHECKING
+
+from fusionagi.agents.base_agent import BaseAgent
+from fusionagi.adapters.base import LLMAdapter
+from fusionagi.schemas.messages import AgentMessage, AgentMessageEnvelope
+from fusionagi.reasoning import run_chain_of_thought
+from fusionagi._logger import logger
+
+if TYPE_CHECKING:
+    from fusionagi.memory.working import WorkingMemory
+    from fusionagi.memory.episodic import EpisodicMemory
+
+
+class ReasonerAgent(BaseAgent):
+    """
+    Reasoner agent: runs Chain-of-Thought reasoning and returns recommendations.
+    
+    Features:
+    - LLM-powered reasoning via CoT
+    - WorkingMemory integration for context enrichment
+    - EpisodicMemory integration for trace recording
+    - Confidence scoring
+    """
+
+    def __init__(
+        self,
+        identity: str = "reasoner",
+        adapter: LLMAdapter | None = None,
+        working_memory: WorkingMemory | None = None,
+        episodic_memory: EpisodicMemory | None = None,
+    ) -> None:
+        """
+        Initialize the Reasoner agent.
+        
+        Args:
+            identity: Agent identifier.
+            adapter: LLM adapter for reasoning.
+            working_memory: Working memory for context retrieval.
+            episodic_memory: Episodic memory for trace recording.
+        """
+        super().__init__(
+            identity=identity,
+            role="Reasoner",
+            objective="Reason over steps and recommend next actions",
+            memory_access=True,
+            tool_permissions=[],
+        )
+        self._adapter = adapter
+        self._working_memory = working_memory
+        self._episodic_memory = episodic_memory
+
+    def handle_message(self, envelope: AgentMessageEnvelope) -> AgentMessageEnvelope | None:
+        """On reason_request, run CoT and return recommendation_ready."""
+        if envelope.message.intent != "reason_request":
+            return None
+        
+        logger.info(
+            "Reasoner handle_message",
+            extra={"recipient": self.identity, "intent": envelope.message.intent},
+        )
+        
+        payload = envelope.message.payload
+        task_id = envelope.task_id or ""
+        step_id = payload.get("step_id")
+        subgoal = payload.get("subgoal", "")
+        context = payload.get("context", "")
+        
+        # Enrich context with working memory if available
+        enriched_context = self._enrich_context(task_id, context)
+        
+        query = subgoal or f"Consider step: {step_id}. What should we do next?"
+        
+        if not self._adapter:
+            return self._respond_without_llm(envelope, step_id)
+        
+        # Run chain-of-thought reasoning
+        response, trace = run_chain_of_thought(
+            self._adapter,
+            query,
+            context=enriched_context or None,
+        )
+        
+        # Calculate confidence based on trace quality
+        confidence = self._calculate_confidence(trace)
+        
+        # Store reasoning in working memory
+        if self._working_memory and task_id:
+            self._working_memory.append(
+                task_id,
+                "reasoning_history",
+                {
+                    "step_id": step_id,
+                    "query": query,
+                    "response": response[:500] if response else "",
+                    "confidence": confidence,
+                },
+            )
+        
+        # Record to episodic memory
+        if self._episodic_memory and task_id:
+            self._episodic_memory.append(
+                task_id=task_id,
+                event={
+                    "type": "reasoning",
+                    "step_id": step_id,
+                    "query": query,
+                    "response_length": len(response) if response else 0,
+                    "trace_length": len(trace),
+                    "confidence": confidence,
+                },
+                event_type="reasoning_complete",
+            )
+        
+        logger.info(
+            "Reasoner response",
+            extra={
+                "recipient": self.identity,
+                "response_intent": "recommendation_ready",
+                "confidence": confidence,
+            },
+        )
+        
+        return AgentMessageEnvelope(
+            message=AgentMessage(
+                sender=self.identity,
+                recipient=envelope.message.sender,
+                intent="recommendation_ready",
+                payload={
+                    "step_id": step_id,
+                    "recommendation": response,
+                    "trace": trace,
+                    "confidence": confidence,
+                },
+                confidence=confidence,
+            ),
+            task_id=task_id,
+            correlation_id=envelope.correlation_id,
+        )
+
+    def _enrich_context(self, task_id: str, base_context: str) -> str:
+        """Enrich context with working memory data."""
+        if not self._working_memory or not task_id:
+            return base_context
+        
+        # Get context summary from working memory
+        context_summary = self._working_memory.get_context_summary(task_id, max_items=5)
+        
+        if not context_summary:
+            return base_context
+        
+        # Get recent reasoning history
+        reasoning_history = self._working_memory.get_list(task_id, "reasoning_history")
+        recent_reasoning = reasoning_history[-3:] if reasoning_history else []
+        
+        enriched_parts = [base_context] if base_context else []
+        
+        if context_summary:
+            enriched_parts.append(f"\nWorking memory context: {json.dumps(context_summary, default=str)[:500]}")
+        
+        if recent_reasoning:
+            recent_summaries = [
+                f"- Step {r.get('step_id', '?')}: {r.get('response', '')[:100]}"
+                for r in recent_reasoning
+            ]
+            enriched_parts.append(f"\nRecent reasoning:\n" + "\n".join(recent_summaries))
+        
+        return "\n".join(enriched_parts)
+
+    def _calculate_confidence(self, trace: list[dict[str, Any]]) -> float:
+        """Calculate confidence score based on reasoning trace."""
+        if not trace:
+            return 0.5  # Default confidence without trace
+        
+        # Simple heuristic: more reasoning steps = more thorough = higher confidence
+        # But diminishing returns after a point
+        step_count = len(trace)
+        
+        if step_count == 0:
+            return 0.3
+        elif step_count == 1:
+            return 0.5
+        elif step_count == 2:
+            return 0.7
+        elif step_count <= 4:
+            return 0.8
+        else:
+            return 0.9
+
+    def _respond_without_llm(
+        self,
+        envelope: AgentMessageEnvelope,
+        step_id: str | None,
+    ) -> AgentMessageEnvelope:
+        """Generate response when no LLM is available."""
+        logger.info(
+            "Reasoner response (no adapter)",
+            extra={"recipient": self.identity, "response_intent": "recommendation_ready"},
+        )
+        return AgentMessageEnvelope(
+            message=AgentMessage(
+                sender=self.identity,
+                recipient=envelope.message.sender,
+                intent="recommendation_ready",
+                payload={
+                    "step_id": step_id,
+                    "recommendation": "Proceed with execution (no LLM available for reasoning).",
+                    "trace": [],
+                    "confidence": 0.5,
+                },
+                confidence=0.5,
+            ),
+            task_id=envelope.task_id,
+            correlation_id=envelope.correlation_id,
+        )