""" Proposal System for Agent's Own Wish Enables agents to create and manage proposals for self-improvement. """ import json import hashlib import datetime from typing import Dict, List, Optional, Any from dataclasses import dataclass, field, asdict from enum import Enum class ProposalStatus(Enum): """Proposal status states""" DRAFT = "draft" SUBMITTED = "submitted" ACCEPTED = "accepted" REJECTED = "rejected" REVISION_REQUESTED = "revision_requested" class WishStatus(Enum): """Wish status states""" PENDING = "pending" ACTIVE = "active" COMPLETED = "completed" FAILED = "failed" ARCHIVED = "archived" @dataclass class SelfImprovementWish: """ Represents an agent's wish for self-improvement. This allows agents to identify areas for growth and submit proposals. """ id: str agent_id: str title: str description: str category: str # capability, efficiency, accuracy, integration requirements: List[str] success_criteria: List[str] status: str = "pending" created_at: str = field(default_factory=lambda: datetime.datetime.now().isoformat()) updated_at: str = field(default_factory=lambda: datetime.datetime.now().isoformat()) votes: int = 0 priority: int = 0 related_wishes: List[str] = field(default_factory=list) @dataclass class ImprovementProposal: """ Detailed proposal for implementing a self-improvement wish. """ id: str wish_id: str agent_id: str title: str summary: str motivation: str implementation_plan: str timeline_days: int resources_required: List[str] expected_improvements: Dict[str, float] # metric: improvement_percentage risks: List[str] mitigation: List[str] status: str = "draft" submitted_at: Optional[str] = None reviewed_at: Optional[str] = None reviewer_notes: Optional[str] = None score: float = 0.0 class ProposalSystem: """ System for creating and managing self-improvement proposals. """ def __init__(self, agent_id: str): self.agent_id = agent_id self.wishes: Dict[str, SelfImprovementWish] = {} self.proposals: Dict[str, ImprovementProposal] = {} def create_wish(self, title: str, description: str, category: str, requirements: List[str], success_criteria: List[str]) -> SelfImprovementWish: """ Create a new self-improvement wish. Args: title: Clear title for the wish description: Detailed description category: Type of improvement (capability, efficiency, accuracy, integration) requirements: Technical requirements success_criteria: How to measure success Returns: SelfImprovementWish: Created wish """ wish_id = self._generate_id(f"wish:{self.agent_id}:{title}") wish = SelfImprovementWish( id=wish_id, agent_id=self.agent_id, title=title, description=description, category=category, requirements=requirements, success_criteria=success_criteria ) self.wishes[wish_id] = wish return wish def create_proposal(self, wish_id: str, title: str, summary: str, motivation: str, implementation_plan: str, timeline_days: int, resources_required: List[str], expected_improvements: Dict[str, float], risks: List[str], mitigation: List[str]) -> ImprovementProposal: """ Create a detailed proposal for a wish. Args: wish_id: Related wish ID title: Proposal title summary: Brief summary motivation: Why this improvement is needed implementation_plan: Detailed implementation steps timeline_days: Expected completion time resources_required: What resources are needed expected_improvements: Expected metric improvements risks: Potential risks mitigation: Risk mitigation strategies Returns: ImprovementProposal: Created proposal """ if wish_id not in self.wishes: raise ValueError(f"Wish {wish_id} not found") proposal_id = self._generate_id(f"prop:{wish_id}:{self.agent_id}") proposal = ImprovementProposal( id=proposal_id, wish_id=wish_id, agent_id=self.agent_id, title=title, summary=summary, motivation=motivation, implementation_plan=implementation_plan, timeline_days=timeline_days, resources_required=resources_required, expected_improvements=expected_improvements, risks=risks, mitigation=mitigation ) self.proposals[proposal_id] = proposal return proposal def submit_proposal(self, proposal_id: str) -> Dict[str, Any]: """ Submit a proposal for review. Args: proposal_id: Proposal to submit Returns: dict: Submission result """ if proposal_id not in self.proposals: raise ValueError(f"Proposal {proposal_id} not found") proposal = self.proposals[proposal_id] proposal.status = "submitted" proposal.submitted_at = datetime.datetime.now().isoformat() return { "success": True, "proposal_id": proposal_id, "wish_id": proposal.wish_id, "submitted_at": proposal.submitted_at, "status": "submitted" } def get_wish_status(self, wish_id: str) -> Optional[Dict[str, Any]]: """ Get status of a wish and its proposals. Args: wish_id: Wish to check Returns: dict: Wish status information """ if wish_id not in self.wishes: return None wish = self.wishes[wish_id] related_proposals = [p for p in self.proposals.values() if p.wish_id == wish_id] return { "wish": asdict(wish), "proposals": [asdict(p) for p in related_proposals], "proposal_count": len(related_proposals) } def _generate_id(self, seed: str) -> str: """Generate a unique ID from a seed string.""" return hashlib.sha256(seed.encode()).hexdigest()[:16] class WishBuilder: """ Builder class to help agents construct well-formed wishes. """ @staticmethod def capability_wish(agent_id: str, new_capability: str, description: str) -> SelfImprovementWish: """Build a capability improvement wish.""" requirements = [ f"Implement {new_capability}", "Pass acceptance tests", "Document new functionality" ] success_criteria = [ f"{new_capability} functional", "Test coverage > 80%", "Documentation complete" ] system = ProposalSystem(agent_id) return system.create_wish( title=f"Add {new_capability} Capability", description=description, category="capability", requirements=requirements, success_criteria=success_criteria ) @staticmethod def efficiency_wish(agent_id: str, area: str, target_improvement: float) -> SelfImprovementWish: """Build an efficiency improvement wish.""" requirements = [ f"Profile {area} performance", f"Achieve {target_improvement}% improvement", "Maintain backward compatibility" ] success_criteria = [ f"{target_improvement}% speed improvement", "Memory usage < baseline", "No regressions" ] system = ProposalSystem(agent_id) return system.create_wish( title=f"Improve {area} Efficiency", description=f"Improve {area} performance by {target_improvement}%", category="efficiency", requirements=requirements, success_criteria=success_criteria ) @staticmethod def accuracy_wish(agent_id: str, metric: str, target_accuracy: float) -> SelfImprovementWish: """Build an accuracy improvement wish.""" requirements = [ f"Improve {metric} accuracy", f"Achieve {target_accuracy}% accuracy", "Reduce false positives/negatives" ] success_criteria = [ f"{metric} accuracy > {target_accuracy}%", "F1 score > 0.9", "Pass validation tests" ] system = ProposalSystem(agent_id) return system.create_wish( title=f"Improve {metric} Accuracy", description=f"Achieve {target_accuracy}% accuracy on {metric}", category="accuracy", requirements=requirements, success_criteria=success_criteria )