kite-agent 0.1.0__py3-none-any.whl

kite/agents/rewoo.py

@@ -0,0 +1,119 @@
+"""
+ReWOO Agent - Reasoning WithOut Observation
+Executes multiple steps in parallel by pre-planning independent tasks.
+"""
+
+import json
+import re
+import asyncio
+from typing import List, Dict, Optional, Any
+from ..agent import Agent
+
+class ReWOOAgent(Agent):
+    """
+    Agent that implements the ReWOO (Reasoning WithOut Observation) pattern.
+    1. Plan: Create a graph of tasks with variable placeholders (#E1, #E2).
+    2. Execute: Resolve dependencies and run tasks (parallel where possible).
+    3. Solver: Combine results for final answer.
+    """
+    
+    def __init__(self, name, system_prompt, tools, framework, llm=None, max_iterations=10, verbose=False):
+        super().__init__(name, system_prompt, tools, framework, llm=llm, max_iterations=max_iterations, verbose=verbose)
+
+    async def run_rewoo(self, goal: str, context: Optional[Dict] = None) -> Dict[str, Any]:
+        """
+        Run the ReWOO loop.
+        """
+        print(f"\n[ReWOO] Goal: {goal}")
+        
+        # Step 1: Create Execution Plan
+        print("  [Step 1] Creating execution graph...")
+        plan_str = await self._generate_rewoo_plan(goal, context)
+        parsing = self._parse_plan(plan_str)
+        
+        # Limit steps to max_iterations
+        if len(parsing) > self.max_iterations:
+            print(f"  [WARNING] ReWOO plan has {len(parsing)} steps, truncating to {self.max_iterations}")
+            parsing = parsing[:self.max_iterations]
+            
+        print(f"  [OK] Planned {len(parsing)} steps")
+        
+        # Step 2: Execute
+        print("  [Step 2] Executing steps...")
+        results = await self._execute_plan(parsing, context)
+        
+        # Step 3: Solve
+        print("  [Step 3] Solving for final answer...")
+        final_answer = await self._solve(goal, results)
+        
+        return {
+            "success": True,
+            "goal": goal,
+            "plan": parsing,
+            "results": results,
+            "answer": final_answer
+        }
+
+    async def _generate_rewoo_plan(self, goal: str, context: Optional[Dict] = None) -> str:
+        tool_desc = "\n".join([f"- {n}: {t.description}" for n, t in self.tools.items()])
+        
+        prompt = f"""You are a ReWOO planner. Create a plan to achieve the goal using available tools.
+Express the plan as a series of steps using placeholders like #E1, #E2 for results.
+
+Available Tools:
+{tool_desc}
+
+Goal: {goal}
+{f"Context: {json.dumps(context)}" if context else ""}
+
+Format:
+Plan: [reasoning]
+#E1 = [tool_name] with [args, can use #E0, etc]
+Plan: [more reasoning]
+#E2 = [tool_name] with [args]
+"""
+        if hasattr(self.llm, 'complete_async'):
+            return await self.llm.complete_async(prompt)
+        return await asyncio.to_thread(self.llm.complete, prompt)
+
+    def _parse_plan(self, plan_str: str) -> List[Dict]:
+        steps = []
+        # Find lines starting with #E[digit]
+        matches = re.findall(r'#E(\d+)\s*=\s*(\w+)\s+(.*)', plan_str)
+        for m in matches:
+            steps.append({
+                "id": f"#E{m[0]}",
+                "tool": m[1],
+                "args": m[2].strip()
+            })
+        return steps
+
+    async def _execute_plan(self, steps: List[Dict], context: Optional[Dict] = None) -> Dict[str, Any]:
+        results = {}
+        
+        for step in steps:
+            # Resolve placeholders in args
+            resolved_args = step['args']
+            for eid, res in results.items():
+                if eid in resolved_args:
+                    resolved_args = resolved_args.replace(eid, str(res))
+            
+            print(f"    Running {step['id']} ({step['tool']})...")
+            # Execute step
+            step_res = await self.run(f"Use {step['tool']} to {resolved_args}", context=context)
+            results[step['id']] = step_res.get('response', 'Error')
+            
+        return results
+
+    async def _solve(self, goal: str, results: Dict[str, Any]) -> str:
+        prompt = f"""Based on the following execution results, provide a final comprehensive answer for the goal.
+
+Goal: {goal}
+
+Results:
+{json.dumps(results, indent=2)}
+
+Final Answer:"""
+        if hasattr(self.llm, 'complete_async'):
+            return await self.llm.complete_async(prompt)
+        return await asyncio.to_thread(self.llm.complete, prompt)

kite/agents/tot.py

@@ -0,0 +1,151 @@
+"""
+Tree-of-Thoughts (ToT) Agent
+Implements multi-path reasoning by generating and evaluating multiple "thoughts" at each step.
+"""
+
+import json
+import asyncio
+from typing import List, Dict, Optional, Any
+from ..agent import Agent
+
+class TreeOfThoughtsAgent(Agent):
+    """
+    Agent that implements the Tree-of-Thoughts pattern.
+    Explores multiple reasoning paths and selects the best one.
+    """
+    
+    def __init__(self, name, system_prompt, tools, framework, llm=None, max_iterations=3, branches=3, verbose=False):
+        super().__init__(name, system_prompt, tools, framework, llm=llm, max_iterations=max_iterations, verbose=verbose)
+        self.branches = branches
+
+    async def run(self, problem: str, context: Optional[Dict] = None) -> Dict[str, Any]:
+        """Override base run to use ToT logic."""
+        return await self.solve_tot(problem)
+
+    async def solve_tot(self, goal: str, max_steps: Optional[int] = None, num_thoughts: Optional[int] = None) -> Dict[str, Any]:
+        """
+        Run the ToT search loop.
+        """
+        depth = max_steps or self.max_iterations
+        branches = num_thoughts or self.branches
+        
+        print(f"\n[TreeOfThoughts] Exploring {branches} branches, depth {depth}")
+        print(f"Goal: {goal}")
+        
+        # 1. Generate initial thoughts
+        initial_thoughts = await self._generate_thoughts_list(goal, depth=0)
+        
+        # 2. Build tree by expanding thoughts recursively
+        tree = []
+        for i, thought in enumerate(initial_thoughts, 1):
+            print(f"  Branch {i}/{len(initial_thoughts)}: {thought[:50]}...")
+            path = await self._explore_path(goal, thought, 1, depth, branches)
+            tree.append(path)
+            
+        # 3. Evaluate and select best path
+        print(f"  [ToT] Evaluating {len(tree)} exploration paths...")
+        best_path = await self._select_best_path(goal, tree)
+        
+        # 4. Final synthesis
+        print("  [ToT] Synthesizing final answer from best path...")
+        final_answer = await self._generate_answer(goal, best_path)
+        
+        return {
+            "success": True,
+            "goal": goal,
+            "explored_paths": len(tree),
+            "best_path": best_path,
+            "answer": final_answer
+        }
+
+    async def _generate_thoughts_list(self, problem: str, depth: int, context: str = "") -> List[str]:
+        """Generate N different thoughts/approaches."""
+        prompt = f"""Generate {self.branches} different approaches to solve this problem.
+
+Problem: {problem}
+Current context: {context if context else "None"}
+
+Generate exactly {self.branches} distinct approaches, each on a new line starting with a number (1., 2., etc.)."""
+
+        response = await self._complete(prompt)
+
+        # Parse thoughts
+        thoughts = []
+        for line in response.split('\n'):
+            line = line.strip()
+            if line and (line[0].isdigit() or line.startswith('-')):
+                # Remove numbering
+                import re
+                thought = re.sub(r'^\d+[\.\)\-]\s*', '', line).strip()
+                if thought:
+                    thoughts.append(thought)
+
+        return thoughts[:self.branches]
+
+    async def _explore_path(self, goal: str, initial_thought: str, current_depth: int, max_depth: int, branches: int) -> List[str]:
+        """Recursively explore a reasoning path."""
+        path = [initial_thought]
+
+        if current_depth >= max_depth:
+            return path
+
+        # Generate next thoughts based on current path
+        context = " -> ".join(path)
+        next_thoughts = await self._generate_thoughts_list(goal, current_depth, context)
+
+        if next_thoughts:
+            # For simplicity, we take the first "best" looking next thought 
+            # or could branches here if doing BFS. We stick to DFS path here.
+            best_next = next_thoughts[0] 
+            rest_of_path = await self._explore_path(goal, best_next, current_depth + 1, max_depth, branches)
+            path.extend(rest_of_path)
+
+        return path
+
+    async def _select_best_path(self, goal: str, tree: List[List[str]]) -> List[str]:
+        """Evaluate all paths and select the best one."""
+        paths_desc = "\n".join([f"Path {i+1}: {' -> '.join(path)}" for i, path in enumerate(tree)])
+        
+        prompt = f"""Evaluate these reasoning paths and select the best one.
+
+Goal: {goal}
+
+Reasoning Paths:
+{paths_desc}
+
+Which path is most likely to lead to a correct and comprehensive solution?
+Respond with ONLY the path number (e.g., 1, 2, or 3)."""
+
+        response = await self._complete(prompt)
+        
+        # Parse selection
+        try:
+            import re
+            match = re.search(r'\d+', response)
+            if match:
+                selection = int(match.group(0)) - 1
+                if 0 <= selection < len(tree):
+                    return tree[selection]
+            return tree[0]
+        except:
+            return tree[0]
+
+    async def _generate_answer(self, goal: str, path: List[str]) -> str:
+        """Generate final answer from best reasoning path."""
+        reasoning = " -> ".join(path)
+
+        prompt = f"""Generate a final comprehensive answer based on this reasoning path.
+
+Goal: {goal}
+Detailed Reasoning: {reasoning}
+
+Final Answer:"""
+
+        return await self._complete(prompt)
+
+    async def _complete(self, prompt: str) -> str:
+        if hasattr(self.llm, 'complete_async'):
+            return await self.llm.complete_async(prompt)
+        else:
+            import asyncio
+            return await asyncio.to_thread(self.llm.complete, prompt)

kite/conversation.py

@@ -0,0 +1,125 @@
+"""
+Conversation Manager
+Handles multi-turn dialogue, context switching, and collaboration between agents.
+"""
+
+import asyncio
+import json
+from typing import List, Dict, Optional, Any, Callable
+from .agent import Agent
+
+class ConversationManager:
+    """
+    Orchestrates multi-turn dialogue between multiple agents.
+    
+    Features:
+    - Multi-turn history management.
+    - Termination conditions (max_turns, consensus).
+    - Collaboration patterns (round-robin).
+    """
+    
+    def __init__(self, 
+                 agents: List[Agent], 
+                 framework,
+                 max_turns: int = 10,
+                 min_turns: int = 3,
+                 termination_condition: str = "consensus"):
+        if not agents or len(agents) == 0:
+            raise ValueError("Conversation requires at least one agent")
+        if max_turns <= 0:
+            raise ValueError("max_turns must be greater than 0")
+            
+        self.agents = agents
+        self.framework = framework
+        self.max_turns = max_turns
+        self.min_turns = min_turns
+        self.termination_condition = termination_condition.lower()
+        self.history = []
+        self.logger = framework.logger
+
+    async def run(self, initial_input: str) -> Dict[str, Any]:
+        """
+        Run the multi-turn conversation.
+        """
+        print(f"\n[Conversation] Starting with input: {initial_input}")
+        
+        current_input = initial_input
+        turn_count = 0
+        consensus_reached = False
+        
+        while turn_count < self.max_turns and not consensus_reached:
+            turn_count += 1
+            # Round-robin turn taking (simplified for now)
+            agent_idx = (turn_count - 1) % len(self.agents)
+            current_agent = self.agents[agent_idx]
+            
+            print(f"  [Turn {turn_count}] Agent: {current_agent.name}")
+            
+            # Prepare context with full history
+            context = {
+                "conversation_history": self.history,
+                "current_turn": turn_count,
+                "max_turns": self.max_turns
+            }
+            
+            # Run agent
+            res = await current_agent.run(current_input, context=context)
+            
+            if not res['success']:
+                print(f"  [Error] Agent {current_agent.name} failed: {res.get('error')}")
+                break
+                
+            response = res['response']
+            self.history.append({
+                "turn": turn_count,
+                "agent": current_agent.name,
+                "content": response
+            })
+            
+            # Check for termination
+            if self.termination_condition == "consensus":
+                consensus_reached = await self._check_consensus(response, turn_count)
+                if consensus_reached:
+                    print(f"  [Consensus] Reached by {current_agent.name}")
+            
+            # Set input for next agent (usually the response of the current one)
+            current_input = response
+            
+        print(f"\n[Conversation] Finished after {turn_count} turns.")
+        
+        return {
+            "success": True,
+            "turns": turn_count,
+            "history": self.history,
+            "final_response": self.history[-1]['content'] if self.history else "No history",
+            "termination": "consensus" if consensus_reached else "max_turns"
+        }
+
+    async def _check_consensus(self, last_response: str, turn_count: int) -> bool:
+        """
+        Check if consensus or a final conclusion has been reached.
+        Only valid after min_turns.
+        """
+        if turn_count < self.min_turns:
+            return False
+            
+        # Stricter declarative markers
+        keywords = [
+            "final consensus reached", 
+            "consensus reached", 
+            "final conclusion:", 
+            "i agree, let's reach a consensus",
+            "we have reached an agreement"
+        ]
+        
+        response_lower = last_response.lower()
+        for kw in keywords:
+            if kw in response_lower:
+                return True
+        
+        return False
+
+    def get_summary(self) -> str:
+        """Synthesize a summary of the conversation."""
+        summary = "\n".join([f"{h['agent']}: {h['content'][:100]}..." for h in self.history])
+        return summary