solana-agent 11.2.0__py3-none-any.whl → 11.3.0__py3-none-any.whl

solana_agent/ai.py

@@ -300,22 +300,31 @@ class AgentType(str, Enum):
 
 
 class Ticket(BaseModel):
-    """Represents a user support ticket."""
-
-    id: str
+    """Model for a support ticket."""
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
     user_id: str
     query: str
-    status: TicketStatus
-    assigned_to: str
-    created_at: datetime.datetime
+    status: TicketStatus = TicketStatus.NEW
+    assigned_to: str = ""
+    created_at: datetime.datetime = Field(
+        default_factory=lambda: datetime.datetime.now(datetime.timezone.utc))
+    updated_at: Optional[datetime.datetime] = None
+    resolved_at: Optional[datetime.datetime] = None
+    resolution_confidence: Optional[float] = None
+    resolution_reasoning: Optional[str] = None
+    handoff_reason: Optional[str] = None
     complexity: Optional[Dict[str, Any]] = None
-    context: Optional[str] = None
+    agent_context: Optional[Dict[str, Any]] = None
     is_parent: bool = False
     is_subtask: bool = False
     parent_id: Optional[str] = None
-    updated_at: Optional[datetime.datetime] = None
-    resolved_at: Optional[datetime.datetime] = None
-    handoff_reason: Optional[str] = None
+
+    # Add fields for resource integration
+    description: Optional[str] = None
+    scheduled_start: Optional[datetime.datetime] = None
+    scheduled_end: Optional[datetime.datetime] = None
+    required_resources: List[Dict[str, Any]] = []
+    resource_assignments: List[Dict[str, Any]] = []
 
 
 class Handoff(BaseModel):
@@ -456,17 +465,22 @@ class PlanStatus(BaseModel):
 
 
 class SubtaskModel(BaseModel):
-    """Represents a subtask breakdown of a complex task."""
+    """Model for a subtask in a complex task breakdown."""
 
     id: str = Field(default_factory=lambda: str(uuid.uuid4()))
-    parent_id: str
+    parent_id: Optional[str] = None
     title: str
     description: str
-    assignee: Optional[str] = None
-    status: TicketStatus = TicketStatus.PLANNING
-    sequence: int
-    dependencies: List[str] = Field(default_factory=list)
-    estimated_minutes: int = 30
+    estimated_minutes: int
+    dependencies: List[str] = []
+    status: str = "pending"
+    priority: Optional[int] = None
+    assigned_to: Optional[str] = None
+    scheduled_start: Optional[datetime.datetime] = None
+    specialization_tags: List[str] = []
+    sequence: int = 0  # Added missing sequence field
+    required_resources: List[Dict[str, Any]] = []
+    resource_assignments: List[Dict[str, Any]] = []
 
 
 class WorkCapacity(BaseModel):
@@ -483,10 +497,117 @@ class WorkCapacity(BaseModel):
     )
 
 
+class ResourceType(str, Enum):
+    """Types of resources that can be booked."""
+    ROOM = "room"
+    VEHICLE = "vehicle"
+    EQUIPMENT = "equipment"
+    SEAT = "seat"
+    DESK = "desk"
+    OTHER = "other"
+
+
+class ResourceStatus(str, Enum):
+    """Status of a resource."""
+    AVAILABLE = "available"
+    IN_USE = "in_use"
+    MAINTENANCE = "maintenance"
+    UNAVAILABLE = "unavailable"
+
+
+class ResourceLocation(BaseModel):
+    """Physical location of a resource."""
+    address: Optional[str] = None
+    building: Optional[str] = None
+    floor: Optional[int] = None
+    room: Optional[str] = None
+    coordinates: Optional[Dict[str, float]] = None  # Lat/Long if applicable
+
+
+class TimeWindow(BaseModel):
+    """Time window model for availability and exceptions."""
+    start: datetime.datetime
+    end: datetime.datetime
+
+    def overlaps_with(self, other: 'TimeWindow') -> bool:
+        """Check if this window overlaps with another one."""
+        return self.start < other.end and self.end > other.start
+
+
+class ResourceAvailabilityWindow(BaseModel):
+    """Availability window for a resource with recurring pattern options."""
+    day_of_week: Optional[List[int]] = None  # 0 = Monday, 6 = Sunday
+    start_time: str  # Format: "HH:MM", 24h format
+    end_time: str  # Format: "HH:MM", 24h format
+    timezone: str = "UTC"
+
+
+class Resource(BaseModel):
+    """Model for a bookable resource."""
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    name: str
+    description: Optional[str] = None
+    resource_type: ResourceType
+    status: ResourceStatus = ResourceStatus.AVAILABLE
+    location: Optional[ResourceLocation] = None
+    capacity: Optional[int] = None  # For rooms/vehicles
+    tags: List[str] = []
+    attributes: Dict[str, str] = {}  # Custom attributes
+    availability_schedule: List[ResourceAvailabilityWindow] = []
+    # Overrides for maintenance, holidays
+    availability_exceptions: List[TimeWindow] = []
+    created_at: datetime.datetime = Field(
+        default_factory=lambda: datetime.datetime.now(datetime.timezone.utc))
+    updated_at: Optional[datetime.datetime] = None
+
+    def is_available_at(self, time_window: TimeWindow) -> bool:
+        """Check if resource is available during the specified time window."""
+        # Check if resource is generally available
+        if self.status != ResourceStatus.AVAILABLE:
+            return False
+
+        # Check against exceptions (maintenance, holidays)
+        for exception in self.availability_exceptions:
+            if exception.overlaps_with(time_window):
+                return False
+
+        # Check if the requested time falls within regular availability
+        day_of_week = time_window.start.weekday()
+        start_time = time_window.start.strftime("%H:%M")
+        end_time = time_window.end.strftime("%H:%M")
+
+        for window in self.availability_schedule:
+            if window.day_of_week is None or day_of_week in window.day_of_week:
+                if window.start_time <= start_time and window.end_time >= end_time:
+                    return True
+
+        # Default available if no schedule defined
+        return len(self.availability_schedule) == 0
+
+
+class ResourceBooking(BaseModel):
+    """Model for a resource booking."""
+    id: str = Field(default_factory=lambda: str(uuid.uuid4()))
+    resource_id: str
+    user_id: str
+    title: str
+    description: Optional[str] = None
+    start_time: datetime.datetime
+    end_time: datetime.datetime
+    status: str = "confirmed"  # confirmed, cancelled, completed
+    booking_reference: Optional[str] = None
+    payment_status: Optional[str] = None
+    payment_amount: Optional[float] = None
+    notes: Optional[str] = None
+    created_at: datetime.datetime = Field(
+        default_factory=lambda: datetime.datetime.now(datetime.timezone.utc))
+    updated_at: Optional[datetime.datetime] = None
+
 #############################################
 # INTERFACES
 #############################################
 
+
 class LLMProvider(Protocol):
     """Interface for language model providers."""
 
@@ -1026,6 +1147,217 @@ class PineconeAdapter:
 # IMPLEMENTATIONS - REPOSITORIES
 #############################################
 
+class ResourceRepository:
+    """Repository for managing resources."""
+
+    def __init__(self, db_provider):
+        """Initialize with database provider."""
+        self.db = db_provider
+        self.resources_collection = "resources"
+        self.bookings_collection = "resource_bookings"
+
+        # Ensure collections exist
+        self.db.create_collection(self.resources_collection)
+        self.db.create_collection(self.bookings_collection)
+
+        # Create indexes
+        self.db.create_index(self.resources_collection, [("resource_type", 1)])
+        self.db.create_index(self.resources_collection, [("status", 1)])
+        self.db.create_index(self.resources_collection, [("tags", 1)])
+
+        self.db.create_index(self.bookings_collection, [("resource_id", 1)])
+        self.db.create_index(self.bookings_collection, [("user_id", 1)])
+        self.db.create_index(self.bookings_collection, [("start_time", 1)])
+        self.db.create_index(self.bookings_collection, [("end_time", 1)])
+        self.db.create_index(self.bookings_collection, [("status", 1)])
+
+    # Resource CRUD operations
+    def create_resource(self, resource: Resource) -> str:
+        """Create a new resource."""
+        resource_dict = resource.model_dump(mode="json")
+        return self.db.insert_one(self.resources_collection, resource_dict)
+
+    def get_resource(self, resource_id: str) -> Optional[Resource]:
+        """Get a resource by ID."""
+        data = self.db.find_one(self.resources_collection, {"id": resource_id})
+        return Resource(**data) if data else None
+
+    def update_resource(self, resource: Resource) -> bool:
+        """Update a resource."""
+        resource.updated_at = datetime.datetime.now(datetime.timezone.utc)
+        resource_dict = resource.model_dump(mode="json")
+        return self.db.update_one(
+            self.resources_collection,
+            {"id": resource.id},
+            {"$set": resource_dict}
+        )
+
+    def delete_resource(self, resource_id: str) -> bool:
+        """Delete a resource."""
+        return self.db.delete_one(self.resources_collection, {"id": resource_id})
+
+    def find_resources(
+        self,
+        query: Dict[str, Any],
+        sort_by: Optional[str] = None,
+        limit: int = 0
+    ) -> List[Resource]:
+        """Find resources matching query."""
+        sort_params = [(sort_by, 1)] if sort_by else [("name", 1)]
+        data = self.db.find(self.resources_collection,
+                            query, sort_params, limit)
+        return [Resource(**item) for item in data]
+
+    def find_available_resources(
+        self,
+        resource_type: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        start_time: Optional[datetime.datetime] = None,
+        end_time: Optional[datetime.datetime] = None,
+        capacity: Optional[int] = None
+    ) -> List[Resource]:
+        """Find available resources matching the criteria."""
+        # Build base query for available resources
+        query = {"status": ResourceStatus.AVAILABLE}
+
+        if resource_type:
+            query["resource_type"] = resource_type
+
+        if tags:
+            query["tags"] = {"$all": tags}
+
+        if capacity:
+            query["capacity"] = {"$gte": capacity}
+
+        # First get resources that match base criteria
+        resources = self.find_resources(query)
+
+        # If no time range specified, return all matching resources
+        if not start_time or not end_time:
+            return resources
+
+        # Filter by time availability (check bookings and exceptions)
+        time_window = TimeWindow(start=start_time, end=end_time)
+
+        # Check each resource's availability
+        available_resources = []
+        for resource in resources:
+            if resource.is_available_at(time_window):
+                # Check existing bookings
+                if not self._has_conflicting_bookings(resource.id, start_time, end_time):
+                    available_resources.append(resource)
+
+        return available_resources
+
+    # Booking CRUD operations
+    def create_booking(self, booking: ResourceBooking) -> str:
+        """Create a new booking."""
+        booking_dict = booking.model_dump(mode="json")
+        return self.db.insert_one(self.bookings_collection, booking_dict)
+
+    def get_booking(self, booking_id: str) -> Optional[ResourceBooking]:
+        """Get a booking by ID."""
+        data = self.db.find_one(self.bookings_collection, {"id": booking_id})
+        return ResourceBooking(**data) if data else None
+
+    def update_booking(self, booking: ResourceBooking) -> bool:
+        """Update a booking."""
+        booking.updated_at = datetime.datetime.now(datetime.timezone.utc)
+        booking_dict = booking.model_dump(mode="json")
+        return self.db.update_one(
+            self.bookings_collection,
+            {"id": booking.id},
+            {"$set": booking_dict}
+        )
+
+    def cancel_booking(self, booking_id: str) -> bool:
+        """Cancel a booking."""
+        return self.db.update_one(
+            self.bookings_collection,
+            {"id": booking_id},
+            {
+                "$set": {
+                    "status": "cancelled",
+                    "updated_at": datetime.datetime.now(datetime.timezone.utc)
+                }
+            }
+        )
+
+    def get_resource_bookings(
+        self,
+        resource_id: str,
+        start_time: Optional[datetime.datetime] = None,
+        end_time: Optional[datetime.datetime] = None,
+        include_cancelled: bool = False
+    ) -> List[ResourceBooking]:
+        """Get all bookings for a resource within a time range."""
+        query = {"resource_id": resource_id}
+
+        if not include_cancelled:
+            query["status"] = {"$ne": "cancelled"}
+
+        if start_time or end_time:
+            time_query = {}
+            if start_time:
+                time_query["$lte"] = end_time
+            if end_time:
+                time_query["$gte"] = start_time
+            if time_query:
+                query["$or"] = [
+                    {"start_time": time_query},
+                    {"end_time": time_query},
+                    {
+                        "$and": [
+                            {"start_time": {"$lte": start_time}},
+                            {"end_time": {"$gte": end_time}}
+                        ]
+                    }
+                ]
+
+        data = self.db.find(self.bookings_collection,
+                            query, sort=[("start_time", 1)])
+        return [ResourceBooking(**item) for item in data]
+
+    def get_user_bookings(
+        self,
+        user_id: str,
+        include_cancelled: bool = False
+    ) -> List[ResourceBooking]:
+        """Get all bookings for a user."""
+        query = {"user_id": user_id}
+
+        if not include_cancelled:
+            query["status"] = {"$ne": "cancelled"}
+
+        data = self.db.find(self.bookings_collection,
+                            query, sort=[("start_time", 1)])
+        return [ResourceBooking(**item) for item in data]
+
+    def _has_conflicting_bookings(
+        self,
+        resource_id: str,
+        start_time: datetime.datetime,
+        end_time: datetime.datetime
+    ) -> bool:
+        """Check if there are any conflicting bookings."""
+        query = {
+            "resource_id": resource_id,
+            "status": {"$ne": "cancelled"},
+            "$or": [
+                {"start_time": {"$lt": end_time, "$gte": start_time}},
+                {"end_time": {"$gt": start_time, "$lte": end_time}},
+                {
+                    "$and": [
+                        {"start_time": {"$lte": start_time}},
+                        {"end_time": {"$gte": end_time}}
+                    ]
+                }
+            ]
+        }
+
+        return self.db.count_documents(self.bookings_collection, query) > 0
+
+
 class MongoMemoryProvider:
     """MongoDB implementation of MemoryProvider."""
 
@@ -2654,6 +2986,143 @@ class AgentService:
         return self.ai_agents
 
 
+class ResourceService:
+    """Service for managing resources and bookings."""
+
+    def __init__(self, resource_repository: ResourceRepository):
+        """Initialize with resource repository."""
+        self.repository = resource_repository
+
+    async def create_resource(self, resource_data, resource_type):
+        """Create a new resource from dictionary data."""
+        # Generate UUID for ID since it can't be None
+        resource_id = str(uuid.uuid4())
+
+        resource = Resource(
+            id=resource_id,
+            name=resource_data["name"],
+            resource_type=resource_type,
+            description=resource_data.get("description"),
+            location=resource_data.get("location"),
+            capacity=resource_data.get("capacity"),
+            tags=resource_data.get("tags", []),
+            attributes=resource_data.get("attributes", {}),
+            availability_schedule=resource_data.get(
+                "availability_schedule", [])
+        )
+
+        # Don't use await when calling repository methods
+        return self.repository.create_resource(resource)
+
+    async def get_resource(self, resource_id):
+        """Get a resource by ID."""
+        # Don't use await
+        return self.repository.get_resource(resource_id)
+
+    async def update_resource(self, resource_id, updates):
+        """Update a resource."""
+        resource = self.repository.get_resource(resource_id)
+        if not resource:
+            return False
+
+        # Apply updates
+        for key, value in updates.items():
+            if hasattr(resource, key):
+                setattr(resource, key, value)
+
+        # Don't use await
+        return self.repository.update_resource(resource)
+
+    async def list_resources(self, resource_type=None):
+        """List all resources, optionally filtered by type."""
+        # Don't use await
+        return self.repository.list_resources(resource_type)
+
+    async def find_available_resources(self, start_time, end_time, capacity=None, tags=None, resource_type=None):
+        """Find available resources for a time period."""
+        # Don't use await
+        resources = self.repository.find_resources(
+            resource_type, capacity, tags)
+
+        # Filter by availability
+        available = []
+        for resource in resources:
+            time_window = TimeWindow(start=start_time, end=end_time)
+            if resource.is_available_at(time_window):
+                if not self.repository._has_conflicting_bookings(resource.id, start_time, end_time):
+                    available.append(resource)
+
+        return available
+
+    async def create_booking(self, resource_id, user_id, title, start_time, end_time, description=None, notes=None):
+        """Create a booking for a resource."""
+        # Check if resource exists
+        resource = self.repository.get_resource(resource_id)
+        if not resource:
+            return False, None, "Resource not found"
+
+        # Check for conflicts
+        if self.repository._has_conflicting_bookings(resource_id, start_time, end_time):
+            return False, None, "Resource is already booked during the requested time"
+
+        # Create booking
+        booking_data = ResourceBooking(
+            id=str(uuid.uuid4()),
+            resource_id=resource_id,
+            user_id=user_id,
+            title=title,
+            description=description,
+            status="confirmed",
+            start_time=start_time,
+            end_time=end_time,
+            notes=notes,
+            created_at=datetime.datetime.now(datetime.timezone.utc)
+        )
+
+        booking_id = self.repository.create_booking(booking_data)
+
+        # Return (success, booking_id, error)
+        return True, booking_id, None
+
+    async def cancel_booking(self, booking_id, user_id):
+        """Cancel a booking."""
+        # Verify booking exists
+        booking = self.repository.get_booking(booking_id)
+        if not booking:
+            return False, "Booking not found"
+
+        # Verify user owns the booking
+        if booking.user_id != user_id:
+            return False, "Not authorized to cancel this booking"
+
+        # Cancel booking
+        result = self.repository.cancel_booking(booking_id)
+        if result:
+            return True, None
+        return False, "Failed to cancel booking"
+
+    async def get_resource_schedule(self, resource_id, start_date, end_date):
+        """Get a resource's schedule for a date range."""
+        return self.repository.get_resource_schedule(resource_id, start_date, end_date)
+
+    async def get_user_bookings(self, user_id, include_cancelled=False):
+        """Get all bookings for a user with resource details."""
+        bookings = self.repository.get_user_bookings(
+            user_id,
+            include_cancelled
+        )
+
+        result = []
+        for booking in bookings:
+            resource = self.repository.get_resource(booking.resource_id)
+            result.append({
+                "booking": booking.model_dump(),
+                "resource": resource.model_dump() if resource else None
+            })
+
+        return result
+
+
 class TaskPlanningService:
     """Service for managing complex task planning and breakdown."""
 
@@ -3008,6 +3477,181 @@ class TaskPlanningService:
                 "domain_knowledge": 5,
             }
 
+    async def generate_subtasks_with_resources(
+        self, ticket_id: str, task_description: str
+    ) -> List[SubtaskModel]:
+        """Generate subtasks for a complex task with resource requirements."""
+        # Fetch ticket to verify it exists
+        ticket = self.ticket_repository.get_by_id(ticket_id)
+        if not ticket:
+            raise ValueError(f"Ticket {ticket_id} not found")
+
+        # Mark parent ticket as a parent
+        self.ticket_repository.update(
+            ticket_id, {"is_parent": True, "status": TicketStatus.PLANNING}
+        )
+
+        # Generate subtasks using LLM
+        agent_name = next(iter(self.agent_service.get_all_ai_agents().keys()))
+        agent_config = self.agent_service.get_all_ai_agents()[agent_name]
+        model = agent_config.get("model", "gpt-4o-mini")
+
+        prompt = f"""
+        Break down the following complex task into logical subtasks with resource requirements:
+        
+        TASK: {task_description}
+        
+        For each subtask, provide:
+        1. A brief title
+        2. A clear description of what needs to be done
+        3. An estimate of time required in minutes
+        4. Any dependencies (which subtasks must be completed first)
+        5. Required resources with these details:
+           - Resource type (room, equipment, etc.)
+           - Quantity needed
+           - Specific requirements (e.g., "room with projector", "laptop with design software")
+        
+        Format as a JSON array of objects with these fields:
+        - title: string
+        - description: string
+        - estimated_minutes: number
+        - dependencies: array of previous subtask titles that must be completed first
+        - required_resources: array of objects with fields:
+          - resource_type: string
+          - quantity: number
+          - requirements: string (specific features needed)
+        
+        The subtasks should be in a logical sequence. Keep dependencies minimal and avoid circular dependencies.
+        """
+
+        response_text = ""
+        async for chunk in self.llm_provider.generate_text(
+            ticket.user_id,
+            prompt,
+            system_prompt="You are an expert project planner who breaks down complex tasks efficiently and identifies required resources.",
+            stream=False,
+            model=model,
+            temperature=0.2,
+            response_format={"type": "json_object"},
+        ):
+            response_text += chunk
+
+        try:
+            data = json.loads(response_text)
+            subtasks_data = data.get("subtasks", [])
+
+            # Create subtask objects
+            subtasks = []
+            for i, task_data in enumerate(subtasks_data):
+                subtask = SubtaskModel(
+                    parent_id=ticket_id,
+                    title=task_data.get("title", f"Subtask {i+1}"),
+                    description=task_data.get("description", ""),
+                    estimated_minutes=task_data.get("estimated_minutes", 30),
+                    dependencies=[],  # We'll fill this after all subtasks are created
+                    status="planning",
+                    required_resources=task_data.get("required_resources", []),
+                    is_subtask=True,
+                    created_at=datetime.datetime.now(datetime.timezone.utc)
+                )
+                subtasks.append(subtask)
+
+            # Process dependencies (convert title references to IDs)
+            title_to_id = {task.title: task.id for task in subtasks}
+            for i, task_data in enumerate(subtasks_data):
+                dependency_titles = task_data.get("dependencies", [])
+                for title in dependency_titles:
+                    if title in title_to_id:
+                        subtasks[i].dependencies.append(title_to_id[title])
+
+            # Store subtasks in database
+            for subtask in subtasks:
+                self.ticket_repository.create(subtask)
+
+            return subtasks
+
+        except Exception as e:
+            print(f"Error generating subtasks with resources: {e}")
+            return []
+
+    async def allocate_resources(
+        self, subtask_id: str, resource_service: ResourceService
+    ) -> Tuple[bool, str]:
+        """Allocate resources to a subtask."""
+        # Get the subtask
+        subtask = self.ticket_repository.get_by_id(subtask_id)
+        if not subtask or not subtask.is_subtask:
+            return False, "Subtask not found"
+
+        if not subtask.required_resources:
+            return True, "No resources required"
+
+        if not subtask.scheduled_start or not subtask.scheduled_end:
+            return False, "Subtask must be scheduled before resources can be allocated"
+
+        # For each required resource
+        resource_assignments = []
+        for resource_req in subtask.required_resources:
+            resource_type = resource_req.get("resource_type")
+            requirements = resource_req.get("requirements", "")
+            quantity = resource_req.get("quantity", 1)
+
+            # Find available resources matching the requirements
+            resources = await resource_service.find_available_resources(
+                start_time=subtask.scheduled_start,
+                end_time=subtask.scheduled_end,
+                resource_type=resource_type,
+                tags=requirements.split() if requirements else None,
+                capacity=None  # Could use quantity here if it represents capacity
+            )
+
+            if not resources or len(resources) < quantity:
+                return False, f"Insufficient {resource_type} resources available"
+
+            # Allocate the resources by creating bookings
+            allocated_resources = []
+            for i in range(quantity):
+                if i >= len(resources):
+                    break
+
+                resource = resources[i]
+                success, booking_id, error = await resource_service.create_booking(
+                    resource_id=resource.id,
+                    user_id=subtask.assigned_to or "system",
+                    # Use query instead of title
+                    title=f"Task: {subtask.query}",
+                    start_time=subtask.scheduled_start,
+                    end_time=subtask.scheduled_end,
+                    description=subtask.description
+                )
+
+                if success:
+                    allocated_resources.append({
+                        "resource_id": resource.id,
+                        "resource_name": resource.name,
+                        "booking_id": booking_id,
+                        "resource_type": resource.resource_type
+                    })
+                else:
+                    # Clean up any allocations already made
+                    for alloc in allocated_resources:
+                        await resource_service.cancel_booking(alloc["booking_id"], subtask.assigned_to or "system")
+                    return False, f"Failed to book resource: {error}"
+
+            resource_assignments.append({
+                "requirement": resource_req,
+                "allocated": allocated_resources
+            })
+
+        # Update the subtask with resource assignments
+        subtask.resource_assignments = resource_assignments
+        self.ticket_repository.update(subtask_id, {
+            "resource_assignments": resource_assignments,
+            "updated_at": datetime.datetime.now(datetime.timezone.utc)
+        })
+
+        return True, f"Successfully allocated {len(resource_assignments)} resource types"
+
 
 class ProjectApprovalService:
     """Service for managing human approval of new projects."""
@@ -3777,6 +4421,77 @@ class SchedulingService:
 
         return task
 
+    async def find_optimal_time_slot_with_resources(
+        self,
+        task: ScheduledTask,
+        resource_service: ResourceService,
+        agent_schedule: Optional[AgentSchedule] = None
+    ) -> Optional[TimeWindow]:
+        """Find the optimal time slot for a task based on both agent and resource availability."""
+        if not task.assigned_to:
+            return None
+
+        # First, find potential time slots based on agent availability
+        agent_id = task.assigned_to
+        duration = task.estimated_minutes or 30
+
+        # Start no earlier than now
+        start_after = datetime.datetime.now(datetime.timezone.utc)
+
+        # Apply task constraints
+        for constraint in task.constraints:
+            if constraint.get("type") == "must_start_after" and constraint.get("time"):
+                constraint_time = datetime.datetime.fromisoformat(
+                    constraint["time"])
+                if constraint_time > start_after:
+                    start_after = constraint_time
+
+        # Get potential time slots for the agent
+        agent_slots = await self.find_available_time_slots(
+            agent_id,
+            duration,
+            start_after,
+            count=3,  # Get multiple slots to try with resources
+            agent_schedule=agent_schedule
+        )
+
+        if not agent_slots:
+            return None
+
+        # Check if task has resource requirements
+        required_resources = getattr(task, "required_resources", [])
+        if not required_resources:
+            # If no resources needed, return the first available agent slot
+            return agent_slots[0]
+
+        # For each potential time slot, check resource availability
+        for time_slot in agent_slots:
+            all_resources_available = True
+
+            for resource_req in required_resources:
+                resource_type = resource_req.get("resource_type")
+                requirements = resource_req.get("requirements", "")
+                quantity = resource_req.get("quantity", 1)
+
+                # Find available resources for this time slot
+                resources = await resource_service.find_available_resources(
+                    start_time=time_slot.start,
+                    end_time=time_slot.end,
+                    resource_type=resource_type,
+                    tags=requirements.split() if requirements else None
+                )
+
+                if len(resources) < quantity:
+                    all_resources_available = False
+                    break
+
+            # If all resources are available, use this time slot
+            if all_resources_available:
+                return time_slot
+
+        # If no time slot has all resources available, default to first slot
+        return agent_slots[0]
+
     async def optimize_schedule(self) -> Dict[str, Any]:
         """Optimize the entire schedule to maximize efficiency."""
         # Get all pending and scheduled tasks
@@ -4431,6 +5146,7 @@ class SchedulingService:
 
         return formatted_requests
 
+
 #############################################
 # MAIN AGENT PROCESSOR
 #############################################
@@ -4709,7 +5425,7 @@ class QueryProcessor:
 
                 return response
 
-            elif command == "!plan" and args:
+            if command == "!plan" and args:
                 # Create a new plan from the task description
                 if not self.task_planning_service:
                     return "Task planning service is not available."
@@ -4721,8 +5437,8 @@ class QueryProcessor:
                     user_id, args, complexity
                 )
 
-                # Generate subtasks
-                subtasks = await self.task_planning_service.generate_subtasks(
+                # Generate subtasks with resource requirements
+                subtasks = await self.task_planning_service.generate_subtasks_with_resources(
                     ticket.id, args
                 )
 
@@ -4736,17 +5452,44 @@ class QueryProcessor:
                 for i, subtask in enumerate(subtasks, 1):
                     response += f"{i}. **{subtask.title}**\n"
                     response += f"   - Description: {subtask.description}\n"
-                    response += (
-                        f"   - Estimated time: {subtask.estimated_minutes} minutes\n"
-                    )
+                    response += f"   - Estimated time: {subtask.estimated_minutes} minutes\n"
+
+                    if subtask.required_resources:
+                        response += f"   - Required resources:\n"
+                        for res in subtask.required_resources:
+                            res_type = res.get("resource_type", "unknown")
+                            quantity = res.get("quantity", 1)
+                            requirements = res.get("requirements", "")
+                            response += f"     * {quantity} {res_type}" + \
+                                (f" ({requirements})" if requirements else "") + "\n"
+
                     if subtask.dependencies:
-                        response += (
-                            f"   - Dependencies: {len(subtask.dependencies)} subtasks\n"
-                        )
+                        response += f"   - Dependencies: {len(subtask.dependencies)} subtasks\n"
+
                     response += "\n"
 
                 return response
 
+            # Add a new command for allocating resources to tasks
+            elif command == "!allocate-resources" and args:
+                parts = args.split()
+                if len(parts) < 1:
+                    return "Usage: !allocate-resources [subtask_id]"
+
+                subtask_id = parts[0]
+
+                if not hasattr(self, "resource_service") or not self.resource_service:
+                    return "Resource service is not available."
+
+                success, message = await self.task_planning_service.allocate_resources(
+                    subtask_id, self.resource_service
+                )
+
+                if success:
+                    return f"✅ Resources allocated successfully: {message}"
+                else:
+                    return f"❌ Failed to allocate resources: {message}"
+
             elif command == "!status" and args:
                 # Show status of a specific plan
                 if not self.task_planning_service:
@@ -4993,6 +5736,379 @@ class QueryProcessor:
 
                 return response
 
+            elif command == "!resources" and self.resource_service:
+                # Format: !resources [list|find|show|create|update|delete]
+                parts = args.strip().split(" ", 1)
+                subcommand = parts[0] if parts else "list"
+                subcmd_args = parts[1] if len(parts) > 1 else ""
+
+                if subcommand == "list":
+                    # List available resources, optionally filtered by type
+                    resource_type = subcmd_args if subcmd_args else None
+
+                    query = {}
+                    if resource_type:
+                        query["resource_type"] = resource_type
+
+                    resources = self.resource_service.repository.find_resources(
+                        query)
+
+                    if not resources:
+                        return "No resources found."
+
+                    response = "# Available Resources\n\n"
+
+                    # Group by type
+                    resources_by_type = {}
+                    for resource in resources:
+                        r_type = resource.resource_type
+                        if r_type not in resources_by_type:
+                            resources_by_type[r_type] = []
+                        resources_by_type[r_type].append(resource)
+
+                    for r_type, r_list in resources_by_type.items():
+                        response += f"## {r_type.capitalize()}\n\n"
+                        for resource in r_list:
+                            status_emoji = "🟢" if resource.status == "available" else "🔴"
+                            response += f"{status_emoji} **{resource.name}** (ID: {resource.id})\n"
+                            if resource.description:
+                                response += f"   {resource.description}\n"
+                            if resource.location and resource.location.building:
+                                response += f"   Location: {resource.location.building}"
+                                if resource.location.room:
+                                    response += f", Room {resource.location.room}"
+                                response += "\n"
+                            if resource.capacity:
+                                response += f"   Capacity: {resource.capacity}\n"
+                            response += "\n"
+
+                    return response
+
+                elif subcommand == "show" and subcmd_args:
+                    # Show details for a specific resource
+                    resource_id = subcmd_args.strip()
+                    resource = await self.resource_service.get_resource(resource_id)
+
+                    if not resource:
+                        return f"Resource with ID {resource_id} not found."
+
+                    response = f"# Resource: {resource.name}\n\n"
+                    response += f"**ID**: {resource.id}\n"
+                    response += f"**Type**: {resource.resource_type}\n"
+                    response += f"**Status**: {resource.status}\n"
+
+                    if resource.description:
+                        response += f"\n**Description**: {resource.description}\n"
+
+                    if resource.location:
+                        response += "\n**Location**:\n"
+                        if resource.location.address:
+                            response += f"- Address: {resource.location.address}\n"
+                        if resource.location.building:
+                            response += f"- Building: {resource.location.building}\n"
+                        if resource.location.floor is not None:
+                            response += f"- Floor: {resource.location.floor}\n"
+                        if resource.location.room:
+                            response += f"- Room: {resource.location.room}\n"
+
+                    if resource.capacity:
+                        response += f"\n**Capacity**: {resource.capacity}\n"
+
+                    if resource.tags:
+                        response += f"\n**Tags**: {', '.join(resource.tags)}\n"
+
+                    # Show availability schedule
+                    if resource.availability_schedule:
+                        response += "\n**Regular Availability**:\n"
+                        for window in resource.availability_schedule:
+                            days = "Every day"
+                            if window.day_of_week:
+                                day_names = [
+                                    "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
+                                days = ", ".join([day_names[d]
+                                                 for d in window.day_of_week])
+                            response += f"- {days}: {window.start_time} - {window.end_time} ({window.timezone})\n"
+
+                    # Show upcoming bookings
+                    now = datetime.datetime.now(datetime.timezone.utc)
+                    next_month = now + datetime.timedelta(days=30)
+                    bookings = self.resource_service.repository.get_resource_bookings(
+                        resource_id, now, next_month)
+
+                    if bookings:
+                        response += "\n**Upcoming Bookings**:\n"
+                        for booking in bookings:
+                            start_str = booking.start_time.strftime(
+                                "%Y-%m-%d %H:%M")
+                            end_str = booking.end_time.strftime("%H:%M")
+                            response += f"- {start_str} - {end_str}: {booking.title}\n"
+
+                    return response
+
+                elif subcommand == "find":
+                    # Find available resources for a time period
+                    # Format: !resources find room 2023-03-15 14:00 16:00
+                    parts = subcmd_args.split()
+                    if len(parts) < 4:
+                        return "Usage: !resources find [type] [date] [start_time] [end_time] [capacity]"
+
+                    resource_type = parts[0]
+                    date_str = parts[1]
+                    start_time_str = parts[2]
+                    end_time_str = parts[3]
+                    capacity = int(parts[4]) if len(parts) > 4 else None
+
+                    try:
+                        # Parse date and times
+                        date_obj = datetime.datetime.strptime(
+                            date_str, "%Y-%m-%d").date()
+                        start_time = datetime.datetime.combine(
+                            date_obj,
+                            datetime.datetime.strptime(
+                                start_time_str, "%H:%M").time(),
+                            tzinfo=datetime.timezone.utc
+                        )
+                        end_time = datetime.datetime.combine(
+                            date_obj,
+                            datetime.datetime.strptime(
+                                end_time_str, "%H:%M").time(),
+                            tzinfo=datetime.timezone.utc
+                        )
+
+                        # Find available resources
+                        resources = await self.resource_service.find_available_resources(
+                            resource_type=resource_type,
+                            start_time=start_time,
+                            end_time=end_time,
+                            capacity=capacity
+                        )
+
+                        if not resources:
+                            return f"No {resource_type}s available for the requested time period."
+
+                        response = f"# Available {resource_type.capitalize()}s\n\n"
+                        response += f"**Date**: {date_str}\n"
+                        response += f"**Time**: {start_time_str} - {end_time_str}\n"
+                        if capacity:
+                            response += f"**Minimum Capacity**: {capacity}\n"
+                        response += "\n"
+
+                        for resource in resources:
+                            response += f"- **{resource.name}** (ID: {resource.id})\n"
+                            if resource.description:
+                                response += f"  {resource.description}\n"
+                            if resource.capacity:
+                                response += f"  Capacity: {resource.capacity}\n"
+                            if resource.location and resource.location.building:
+                                response += f"  Location: {resource.location.building}"
+                                if resource.location.room:
+                                    response += f", Room {resource.location.room}"
+                                response += "\n"
+                            response += "\n"
+
+                        return response
+
+                    except ValueError as e:
+                        return f"Error parsing date/time: {e}"
+
+                elif subcommand == "book":
+                    # Book a resource
+                    # Format: !resources book [resource_id] [date] [start_time] [end_time] [title]
+                    parts = subcmd_args.split(" ", 5)
+                    if len(parts) < 5:
+                        return "Usage: !resources book [resource_id] [date] [start_time] [end_time] [title]"
+
+                    resource_id = parts[0]
+                    date_str = parts[1]
+                    start_time_str = parts[2]
+                    end_time_str = parts[3]
+                    title = parts[4] if len(parts) > 4 else "Booking"
+
+                    try:
+                        # Parse date and times
+                        date_obj = datetime.datetime.strptime(
+                            date_str, "%Y-%m-%d").date()
+                        start_time = datetime.datetime.combine(
+                            date_obj,
+                            datetime.datetime.strptime(
+                                start_time_str, "%H:%M").time(),
+                            tzinfo=datetime.timezone.utc
+                        )
+                        end_time = datetime.datetime.combine(
+                            date_obj,
+                            datetime.datetime.strptime(
+                                end_time_str, "%H:%M").time(),
+                            tzinfo=datetime.timezone.utc
+                        )
+
+                        # Create booking
+                        success, booking, error = await self.resource_service.create_booking(
+                            resource_id=resource_id,
+                            user_id=user_id,
+                            title=title,
+                            start_time=start_time,
+                            end_time=end_time
+                        )
+
+                        if not success:
+                            return f"Failed to book resource: {error}"
+
+                        # Get resource details
+                        resource = await self.resource_service.get_resource(resource_id)
+                        resource_name = resource.name if resource else resource_id
+
+                        response = "# Booking Confirmed\n\n"
+                        response += f"**Resource**: {resource_name}\n"
+                        response += f"**Date**: {date_str}\n"
+                        response += f"**Time**: {start_time_str} - {end_time_str}\n"
+                        response += f"**Title**: {title}\n"
+                        response += f"**Booking ID**: {booking.id}\n\n"
+                        response += "Your booking has been confirmed and added to your schedule."
+
+                        return response
+
+                    except ValueError as e:
+                        return f"Error parsing date/time: {e}"
+
+                elif subcommand == "bookings":
+                    # View all bookings for the current user
+                    include_cancelled = "all" in subcmd_args.lower()
+
+                    bookings = await self.resource_service.get_user_bookings(user_id, include_cancelled)
+
+                    if not bookings:
+                        return "You don't have any bookings." + (
+                            " (Use 'bookings all' to include cancelled bookings)" if not include_cancelled else ""
+                        )
+
+                    response = "# Your Bookings\n\n"
+
+                    # Group bookings by date
+                    bookings_by_date = {}
+                    for booking_data in bookings:
+                        booking = booking_data["booking"]
+                        resource = booking_data["resource"]
+
+                        date_str = booking["start_time"].strftime("%Y-%m-%d")
+                        if date_str not in bookings_by_date:
+                            bookings_by_date[date_str] = []
+
+                        bookings_by_date[date_str].append((booking, resource))
+
+                    # Sort dates
+                    for date_str in sorted(bookings_by_date.keys()):
+                        response += f"## {date_str}\n\n"
+
+                        for booking, resource in bookings_by_date[date_str]:
+                            start_time = booking["start_time"].strftime(
+                                "%H:%M")
+                            end_time = booking["end_time"].strftime("%H:%M")
+                            resource_name = resource["name"] if resource else "Unknown Resource"
+
+                            status_emoji = "🟢" if booking["status"] == "confirmed" else "🔴"
+                            response += f"{status_emoji} **{start_time}-{end_time}**: {booking['title']}\n"
+                            response += f"   Resource: {resource_name}\n"
+                            response += f"   Booking ID: {booking['id']}\n\n"
+
+                    return response
+
+                elif subcommand == "cancel" and subcmd_args:
+                    # Cancel a booking
+                    booking_id = subcmd_args.strip()
+
+                    success, error = await self.resource_service.cancel_booking(booking_id, user_id)
+
+                    if success:
+                        return "✅ Your booking has been successfully cancelled."
+                    else:
+                        return f"❌ Failed to cancel booking: {error}"
+
+                elif subcommand == "schedule" and subcmd_args:
+                    # View resource schedule
+                    # Format: !resources schedule resource_id [YYYY-MM-DD] [days]
+                    parts = subcmd_args.split()
+                    if len(parts) < 1:
+                        return "Usage: !resources schedule resource_id [YYYY-MM-DD] [days]"
+
+                    resource_id = parts[0]
+
+                    # Default to today and 7 days
+                    start_date = datetime.datetime.now(datetime.timezone.utc)
+                    days = 7
+
+                    if len(parts) > 1:
+                        try:
+                            start_date = datetime.datetime.strptime(
+                                parts[1], "%Y-%m-%d"
+                            ).replace(tzinfo=datetime.timezone.utc)
+                        except ValueError:
+                            return "Invalid date format. Use YYYY-MM-DD."
+
+                    if len(parts) > 2:
+                        try:
+                            days = min(int(parts[2]), 31)  # Limit to 31 days
+                        except ValueError:
+                            return "Days must be a number."
+
+                    end_date = start_date + datetime.timedelta(days=days)
+
+                    # Get the resource
+                    resource = await self.resource_service.get_resource(resource_id)
+                    if not resource:
+                        return f"Resource with ID {resource_id} not found."
+
+                    # Get schedule
+                    schedule = await self.resource_service.get_resource_schedule(
+                        resource_id, start_date, end_date
+                    )
+
+                    # Create calendar visualization
+                    response = f"# Schedule for {resource.name}\n\n"
+                    response += f"Period: {start_date.strftime('%Y-%m-%d')} to {end_date.strftime('%Y-%m-%d')}\n\n"
+
+                    # Group by date
+                    schedule_by_date = {}
+                    current_date = start_date
+                    while current_date < end_date:
+                        date_str = current_date.strftime("%Y-%m-%d")
+                        schedule_by_date[date_str] = []
+                        current_date += datetime.timedelta(days=1)
+
+                    # Add entries to appropriate dates
+                    for entry in schedule:
+                        date_str = entry["start_time"].strftime("%Y-%m-%d")
+                        if date_str in schedule_by_date:
+                            schedule_by_date[date_str].append(entry)
+
+                    # Generate calendar view
+                    for date_str, entries in schedule_by_date.items():
+                        # Convert to datetime for day of week
+                        entry_date = datetime.datetime.strptime(
+                            date_str, "%Y-%m-%d")
+                        day_of_week = entry_date.strftime("%A")
+
+                        response += f"## {date_str} ({day_of_week})\n\n"
+
+                        if not entries:
+                            response += "No bookings or exceptions\n\n"
+                            continue
+
+                        # Sort by start time
+                        entries.sort(key=lambda x: x["start_time"])
+
+                        for entry in entries:
+                            start_time = entry["start_time"].strftime("%H:%M")
+                            end_time = entry["end_time"].strftime("%H:%M")
+
+                            if entry["type"] == "booking":
+                                response += f"- **{start_time}-{end_time}**: {entry['title']} (by {entry['user_id']})\n"
+                            else:  # exception
+                                response += f"- **{start_time}-{end_time}**: {entry['status']} (Unavailable)\n"
+
+                        response += "\n"
+
+                    return response
+
         return None
 
     async def _process_existing_ticket(

{solana_agent-11.2.0.dist-info → solana_agent-11.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solana-agent
-Version: 11.2.0
+Version: 11.3.0
 Summary: The Future of Work
 License: MIT
 Keywords: ai,openai,ai agents,agi
@@ -200,6 +200,19 @@ Solana Agent transforms organizations into living systems that continuously lear
     Capacity-aware scheduling to prevent agent overloading.  
     Schedule analytics and efficiency metrics.
 
+- **🏢 Comprehensive Resource Management System:**  
+    Complete resource scheduling and booking infrastructure.  
+    Resource categorization with customizable attributes and capabilities.  
+    Intelligent conflict detection and prevention for bookings.  
+    Location-aware resource tracking with hierarchical location model.  
+    Availability management with customizable recurring schedules.  
+    User-level booking authorization with permission controls.  
+    Resource discovery by type, capacity, and available features.  
+    Command-line interface for resource management.  
+    Booking lifecycle management with confirmation and cancellation.  
+    Time-aware resource scheduling across time zones.  
+    Resource utilization analytics and optimization.  
+
 - **📊 Performance Optimization Framework:**  
     Integrated Net Promoter Score (NPS) system for interaction quality measurement.  
     Automatic satisfaction surveys after ticket resolution.  
@@ -212,8 +225,14 @@ Solana Agent transforms organizations into living systems that continuously lear
     Automated complexity assessment for incoming tasks.  
     Task decomposition into subtasks with dependencies.  
     Intelligent workload distribution based on agent capacity.  
+    Resource requirements identification for each subtask.  
+    Automatic resource allocation based on task needs.  
+    Resource-aware scheduling to prevent conflicts.  
+    Integrated resource and agent availability checking.  
+    Command-line interface for resource allocation to tasks.  
     Visual progress tracking with completion estimates.  
-    Prioritization based on urgency, importance, and dependencies.
+    Prioritization based on urgency, importance, and dependencies.  
+    Resource utilization optimization across project timelines.  
 
 - **🛡️ Governance Framework:**  
     Define organization-wide values and operating principles in code.  

solana_agent-11.3.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+solana_agent/__init__.py,sha256=zpfnWqANd3OHGWm7NCF5Y6m01BWG4NkNk8SK9Ex48nA,18
+solana_agent/ai.py,sha256=W5h6hckGY_NAkqFFOQtuocdTbDfJnqNY9_Z7RYYy2K0,290852
+solana_agent-11.3.0.dist-info/LICENSE,sha256=BnSRc-NSFuyF2s496l_4EyrwAP6YimvxWcjPiJ0J7g4,1057
+solana_agent-11.3.0.dist-info/METADATA,sha256=H3juWeX6NQzKqC1mzSLysBURiykMRw_hM9gwfzE-cOE,19603
+solana_agent-11.3.0.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+solana_agent-11.3.0.dist-info/RECORD,,

solana_agent-11.2.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-solana_agent/__init__.py,sha256=zpfnWqANd3OHGWm7NCF5Y6m01BWG4NkNk8SK9Ex48nA,18
-solana_agent/ai.py,sha256=SPHPCQPqk1wuBymB3StNRYp84s9pAa7LOeROBSHiJfQ,243608
-solana_agent-11.2.0.dist-info/LICENSE,sha256=BnSRc-NSFuyF2s496l_4EyrwAP6YimvxWcjPiJ0J7g4,1057
-solana_agent-11.2.0.dist-info/METADATA,sha256=quIlcgag0-hHIAy7-ibsh-JWxpBmravXIeoCp4zXxDw,18468
-solana_agent-11.2.0.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-solana_agent-11.2.0.dist-info/RECORD,,