aiecs 1.0.5__tar.gz → 1.0.6__tar.gz

{aiecs-1.0.5/aiecs.egg-info → aiecs-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiecs
-Version: 1.0.5
+Version: 1.0.6
 Summary: AI Execute Services - A middleware framework for AI-powered task execution and tool orchestration
 Author-email: AIECS Team <iretbl@gmail.com>
 License-Expression: MIT
@@ -37,7 +37,7 @@ Requires-Dist: python-engineio<5.0.0,>=4.12.1
 Requires-Dist: tenacity<10.0.0,>=9.1.2
 Requires-Dist: flower<3.0.0,>=2.0.1
 Requires-Dist: openai<1.76.0,>=1.68.2
-Requires-Dist: google-cloud-aiplatform<2.0.0,>=1.71.1
+Requires-Dist: google-cloud-aiplatform<2.0.0,>=1.80.0
 Requires-Dist: langchain<0.4.0,>=0.3.26
 Requires-Dist: langgraph<0.6.0,>=0.5.3
 Requires-Dist: weasel==0.4.1

{aiecs-1.0.5 → aiecs-1.0.6}/aiecs/__init__.py

@@ -5,7 +5,7 @@ A powerful Python middleware framework for building AI-powered applications
 with tool orchestration, task execution, and multi-provider LLM support.
 """
 
-__version__ = "1.0.5"
+__version__ = "1.0.6"
 __author__ = "AIECS Team"
 __email__ = "iretbl@gmail.com"
 

{aiecs-1.0.5 → aiecs-1.0.6}/aiecs/config/config.py

@@ -5,6 +5,7 @@ from functools import lru_cache
 class Settings(BaseSettings):
     # LLM Provider Configuration (optional until used)
     openai_api_key: str = Field(default="", alias="OPENAI_API_KEY")
+    googleai_api_key: str = Field(default="", alias="GOOGLEAI_API_KEY")
     vertex_project_id: str = Field(default="", alias="VERTEX_PROJECT_ID")
     vertex_location: str = Field(default="us-central1", alias="VERTEX_LOCATION")
     google_application_credentials: str = Field(default="", alias="GOOGLE_APPLICATION_CREDENTIALS")

aiecs-1.0.6/aiecs/domain/community/collaborative_workflow.py

@@ -0,0 +1,407 @@
+"""
+Collaborative Workflow Engine
+
+Orchestrates collaborative workflows within agent communities,
+including brainstorming, problem-solving, and knowledge synthesis.
+"""
+
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Any, Optional
+import uuid
+import asyncio
+
+from .models.community_models import CollaborationSession
+from ..core.exceptions.task_exceptions import TaskValidationError
+
+logger = logging.getLogger(__name__)
+
+
+class CollaborativeWorkflowEngine:
+    """
+    Engine for orchestrating collaborative workflows within agent communities.
+    """
+
+    def __init__(self, community_manager=None, resource_manager=None, decision_engine=None):
+        """
+        Initialize the collaborative workflow engine.
+        
+        Args:
+            community_manager: Reference to the community manager
+            resource_manager: Reference to the resource manager
+            decision_engine: Reference to the decision engine
+        """
+        self.community_manager = community_manager
+        self.resource_manager = resource_manager
+        self.decision_engine = decision_engine
+        
+        # Active collaborative sessions
+        self.active_sessions: Dict[str, CollaborationSession] = {}
+        
+        # Workflow templates
+        self.workflow_templates = {
+            "brainstorming": self._brainstorming_workflow,
+            "problem_solving": self._problem_solving_workflow,
+            "knowledge_synthesis": self._knowledge_synthesis_workflow,
+            "decision_making": self._decision_making_workflow,
+            "resource_creation": self._resource_creation_workflow,
+            "peer_review": self._peer_review_workflow,
+            "consensus_building": self._consensus_building_workflow
+        }
+        
+        logger.info("Collaborative workflow engine initialized")
+
+    async def start_collaborative_session(
+        self,
+        community_id: str,
+        session_leader_id: str,
+        session_type: str,
+        purpose: str,
+        participants: List[str],
+        agenda: Optional[List[str]] = None,
+        duration_minutes: int = 60,
+        session_config: Optional[Dict[str, Any]] = None
+    ) -> str:
+        """
+        Start a collaborative session.
+        
+        Args:
+            community_id: ID of the community
+            session_leader_id: ID of the session leader
+            session_type: Type of collaborative session
+            purpose: Purpose of the session
+            participants: List of participant member IDs
+            agenda: Optional agenda items
+            duration_minutes: Expected duration in minutes
+            session_config: Optional session configuration
+            
+        Returns:
+            Session ID
+        """
+        if not self.community_manager:
+            raise TaskValidationError("Community manager not available")
+        
+        # Validate community and participants
+        community = self.community_manager.communities.get(community_id)
+        if not community:
+            raise TaskValidationError(f"Community not found: {community_id}")
+        
+        # Create collaboration session
+        session = CollaborationSession(
+            community_id=community_id,
+            participants=participants,
+            session_leader=session_leader_id,
+            purpose=purpose,
+            session_type=session_type,
+            agenda=agenda or [],
+            metadata=session_config or {}
+        )
+        
+        self.active_sessions[session.session_id] = session
+        
+        # Execute workflow template if available
+        if session_type in self.workflow_templates:
+            workflow_func = self.workflow_templates[session_type]
+            await workflow_func(session)
+        
+        logger.info(f"Started collaborative session: {session_type} ({session.session_id})")
+        return session.session_id
+
+    async def _brainstorming_workflow(self, session: CollaborationSession) -> None:
+        """
+        Execute brainstorming workflow.
+        
+        Phases:
+        1. Idea generation
+        2. Idea collection and categorization
+        3. Idea evaluation and ranking
+        4. Action item creation
+        """
+        logger.info(f"Starting brainstorming workflow for session {session.session_id}")
+        
+        # Phase 1: Idea Generation
+        await self._execute_phase(session, "idea_generation", {
+            "instructions": "Generate creative ideas related to the session purpose",
+            "time_limit_minutes": 15,
+            "parallel_thinking": True
+        })
+        
+        # Phase 2: Idea Collection
+        await self._execute_phase(session, "idea_collection", {
+            "instructions": "Collect and categorize all generated ideas",
+            "time_limit_minutes": 10,
+            "collaborative": True
+        })
+        
+        # Phase 3: Idea Evaluation
+        await self._execute_phase(session, "idea_evaluation", {
+            "instructions": "Evaluate and rank ideas based on feasibility and impact",
+            "time_limit_minutes": 15,
+            "voting_enabled": True
+        })
+        
+        # Phase 4: Action Planning
+        await self._execute_phase(session, "action_planning", {
+            "instructions": "Create action items for top-ranked ideas",
+            "time_limit_minutes": 10,
+            "assign_responsibilities": True
+        })
+
+    async def _problem_solving_workflow(self, session: CollaborationSession) -> None:
+        """
+        Execute problem-solving workflow.
+        
+        Phases:
+        1. Problem definition and analysis
+        2. Root cause analysis
+        3. Solution brainstorming
+        4. Solution evaluation and selection
+        5. Implementation planning
+        """
+        logger.info(f"Starting problem-solving workflow for session {session.session_id}")
+        
+        # Phase 1: Problem Definition
+        await self._execute_phase(session, "problem_definition", {
+            "instructions": "Define the problem clearly and analyze its scope",
+            "time_limit_minutes": 15,
+            "structured_analysis": True
+        })
+        
+        # Phase 2: Root Cause Analysis
+        await self._execute_phase(session, "root_cause_analysis", {
+            "instructions": "Identify root causes using systematic analysis",
+            "time_limit_minutes": 20,
+            "analysis_methods": ["5_whys", "fishbone", "pareto"]
+        })
+        
+        # Phase 3: Solution Brainstorming
+        await self._execute_phase(session, "solution_brainstorming", {
+            "instructions": "Generate potential solutions for identified root causes",
+            "time_limit_minutes": 20,
+            "creative_thinking": True
+        })
+        
+        # Phase 4: Solution Evaluation
+        await self._execute_phase(session, "solution_evaluation", {
+            "instructions": "Evaluate solutions based on criteria matrix",
+            "time_limit_minutes": 15,
+            "evaluation_criteria": ["feasibility", "impact", "cost", "timeline"]
+        })
+        
+        # Phase 5: Implementation Planning
+        await self._execute_phase(session, "implementation_planning", {
+            "instructions": "Create detailed implementation plan for selected solution",
+            "time_limit_minutes": 15,
+            "create_timeline": True
+        })
+
+    async def _knowledge_synthesis_workflow(self, session: CollaborationSession) -> None:
+        """
+        Execute knowledge synthesis workflow.
+        
+        Phases:
+        1. Knowledge gathering
+        2. Information analysis
+        3. Pattern identification
+        4. Synthesis and integration
+        5. Knowledge artifact creation
+        """
+        logger.info(f"Starting knowledge synthesis workflow for session {session.session_id}")
+        
+        # Phase 1: Knowledge Gathering
+        await self._execute_phase(session, "knowledge_gathering", {
+            "instructions": "Gather relevant knowledge from community resources and expertise",
+            "time_limit_minutes": 20,
+            "resource_search": True
+        })
+        
+        # Phase 2: Information Analysis
+        await self._execute_phase(session, "information_analysis", {
+            "instructions": "Analyze gathered information for relevance and quality",
+            "time_limit_minutes": 15,
+            "quality_assessment": True
+        })
+        
+        # Phase 3: Pattern Identification
+        await self._execute_phase(session, "pattern_identification", {
+            "instructions": "Identify patterns, themes, and connections in the information",
+            "time_limit_minutes": 20,
+            "pattern_analysis": True
+        })
+        
+        # Phase 4: Synthesis
+        await self._execute_phase(session, "synthesis", {
+            "instructions": "Synthesize information into coherent knowledge structure",
+            "time_limit_minutes": 25,
+            "collaborative_editing": True
+        })
+        
+        # Phase 5: Artifact Creation
+        await self._execute_phase(session, "artifact_creation", {
+            "instructions": "Create knowledge artifacts for community sharing",
+            "time_limit_minutes": 15,
+            "create_resources": True
+        })
+
+    async def _decision_making_workflow(self, session: CollaborationSession) -> None:
+        """
+        Execute decision-making workflow.
+        
+        Phases:
+        1. Decision framing
+        2. Option generation
+        3. Criteria definition
+        4. Option evaluation
+        5. Decision and commitment
+        """
+        logger.info(f"Starting decision-making workflow for session {session.session_id}")
+        
+        # Phase 1: Decision Framing
+        await self._execute_phase(session, "decision_framing", {
+            "instructions": "Frame the decision clearly with context and constraints",
+            "time_limit_minutes": 15,
+            "structured_framing": True
+        })
+        
+        # Phase 2: Option Generation
+        await self._execute_phase(session, "option_generation", {
+            "instructions": "Generate multiple decision options",
+            "time_limit_minutes": 20,
+            "creative_options": True
+        })
+        
+        # Phase 3: Criteria Definition
+        await self._execute_phase(session, "criteria_definition", {
+            "instructions": "Define evaluation criteria and their weights",
+            "time_limit_minutes": 10,
+            "criteria_weighting": True
+        })
+        
+        # Phase 4: Option Evaluation
+        await self._execute_phase(session, "option_evaluation", {
+            "instructions": "Evaluate options against defined criteria",
+            "time_limit_minutes": 20,
+            "systematic_evaluation": True
+        })
+        
+        # Phase 5: Decision Making
+        await self._execute_phase(session, "decision_making", {
+            "instructions": "Make final decision and create commitment plan",
+            "time_limit_minutes": 15,
+            "consensus_building": True,
+            "create_decision": True
+        })
+
+    async def _resource_creation_workflow(self, session: CollaborationSession) -> None:
+        """Execute resource creation workflow."""
+        logger.info(f"Starting resource creation workflow for session {session.session_id}")
+        
+        # Phase 1: Resource Planning
+        await self._execute_phase(session, "resource_planning", {
+            "instructions": "Plan the resource to be created",
+            "time_limit_minutes": 15
+        })
+        
+        # Phase 2: Collaborative Creation
+        await self._execute_phase(session, "collaborative_creation", {
+            "instructions": "Collaboratively create the resource",
+            "time_limit_minutes": 30,
+            "collaborative_editing": True
+        })
+        
+        # Phase 3: Review and Refinement
+        await self._execute_phase(session, "review_refinement", {
+            "instructions": "Review and refine the created resource",
+            "time_limit_minutes": 15,
+            "peer_review": True
+        })
+
+    async def _peer_review_workflow(self, session: CollaborationSession) -> None:
+        """Execute peer review workflow."""
+        logger.info(f"Starting peer review workflow for session {session.session_id}")
+        
+        # Implementation for peer review workflow
+        pass
+
+    async def _consensus_building_workflow(self, session: CollaborationSession) -> None:
+        """Execute consensus building workflow."""
+        logger.info(f"Starting consensus building workflow for session {session.session_id}")
+        
+        # Implementation for consensus building workflow
+        pass
+
+    async def _execute_phase(
+        self,
+        session: CollaborationSession,
+        phase_name: str,
+        phase_config: Dict[str, Any]
+    ) -> None:
+        """
+        Execute a workflow phase.
+        
+        Args:
+            session: Collaboration session
+            phase_name: Name of the phase
+            phase_config: Phase configuration
+        """
+        logger.info(f"Executing phase '{phase_name}' for session {session.session_id}")
+        
+        # Record phase execution
+        phase_result = {
+            "phase_name": phase_name,
+            "started_at": datetime.utcnow().isoformat(),
+            "config": phase_config,
+            "participants": session.participants,
+            "outputs": []
+        }
+        
+        # Simulate phase execution (in real implementation, this would coordinate agent activities)
+        time_limit = phase_config.get("time_limit_minutes", 10)
+        await asyncio.sleep(1)  # Simulate processing time
+        
+        phase_result["completed_at"] = datetime.utcnow().isoformat()
+        phase_result["status"] = "completed"
+        
+        # Store phase result in session metadata
+        if "phases" not in session.metadata:
+            session.metadata["phases"] = []
+        session.metadata["phases"].append(phase_result)
+        
+        logger.info(f"Completed phase '{phase_name}' for session {session.session_id}")
+
+    async def end_session(self, session_id: str) -> Dict[str, Any]:
+        """
+        End a collaborative session and generate summary.
+        
+        Args:
+            session_id: ID of the session to end
+            
+        Returns:
+            Session summary
+        """
+        if session_id not in self.active_sessions:
+            raise TaskValidationError(f"Session not found: {session_id}")
+        
+        session = self.active_sessions[session_id]
+        session.status = "completed"
+        session.ended_at = datetime.utcnow()
+        
+        # Generate session summary
+        summary = {
+            "session_id": session_id,
+            "session_type": session.session_type,
+            "purpose": session.purpose,
+            "participants": session.participants,
+            "duration_minutes": (session.ended_at - session.started_at).total_seconds() / 60,
+            "outcomes": session.action_items,
+            "resources_created": session.resources_created,
+            "decisions_made": session.decisions_made,
+            "phases_completed": len(session.metadata.get("phases", [])),
+            "status": session.status
+        }
+        
+        # Remove from active sessions
+        del self.active_sessions[session_id]
+        
+        logger.info(f"Ended collaborative session {session_id}")
+        return summary