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

solana_agent/ai.py

@@ -15,6 +15,7 @@ import datetime
 import json
 import re
 import traceback
+from unittest.mock import AsyncMock
 import uuid
 from enum import Enum
 from typing import (
@@ -299,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):
@@ -455,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):
@@ -482,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."""
 
@@ -1025,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."""
 
@@ -1355,6 +1688,15 @@ class MongoTicketRepository:
         """Count tickets matching query."""
         return self.db.count_documents(self.collection, query)
 
+    def find_stalled_tickets(self, cutoff_time, statuses):
+        """Find tickets that haven't been updated since the cutoff time."""
+        query = {
+            "status": {"$in": [status.value if isinstance(status, Enum) else status for status in statuses]},
+            "updated_at": {"$lt": cutoff_time}
+        }
+        tickets = self.db_adapter.find("tickets", query)
+        return [Ticket(**ticket) for ticket in tickets]
+
 
 class MongoHandoffRepository:
     """MongoDB implementation of HandoffRepository."""
@@ -2644,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."""
 
@@ -2998,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."""
@@ -3018,27 +3672,6 @@ class ProjectApprovalService:
         if agent_id in self.human_agent_registry.get_all_human_agents():
             self.approvers.append(agent_id)
 
-    async def submit_for_approval(self, ticket: Ticket) -> None:
-        """Submit a project for human approval."""
-        # Update ticket status
-        self.ticket_repository.update(
-            ticket.id,
-            {
-                "status": TicketStatus.PENDING,
-                "approval_status": "awaiting_approval",
-                "updated_at": datetime.datetime.now(datetime.timezone.utc),
-            },
-        )
-
-        # Notify approvers
-        if self.notification_service:
-            for approver_id in self.approvers:
-                self.notification_service.send_notification(
-                    approver_id,
-                    f"New project requires approval: {ticket.query}",
-                    {"ticket_id": ticket.id, "type": "approval_request"},
-                )
-
     async def process_approval(
         self, ticket_id: str, approver_id: str, approved: bool, comments: str = ""
     ) -> None:
@@ -3073,6 +3706,27 @@ class ProjectApprovalService:
                 },
             )
 
+    async def submit_for_approval(self, ticket: Ticket) -> None:
+        """Submit a project for human approval."""
+        # Update ticket status
+        self.ticket_repository.update(
+            ticket.id,
+            {
+                "status": TicketStatus.PENDING,
+                "approval_status": "awaiting_approval",
+                "updated_at": datetime.datetime.now(datetime.timezone.utc),
+            },
+        )
+
+        # Notify approvers
+        if self.notification_service and self.approvers:
+            for approver_id in self.approvers:
+                await self.notification_service.send_notification(
+                    approver_id,
+                    f"New project requires approval: {ticket.query}",
+                    {"ticket_id": ticket.id, "type": "approval_request"},
+                )
+
 
 class ProjectSimulationService:
     """Service for simulating project feasibility and requirements using historical data."""
@@ -3767,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
@@ -4421,6 +5146,7 @@ class SchedulingService:
 
         return formatted_requests
 
+
 #############################################
 # MAIN AGENT PROCESSOR
 #############################################
@@ -4446,6 +5172,7 @@ class QueryProcessor:
         project_simulation_service: Optional[ProjectSimulationService] = None,
         require_human_approval: bool = False,
         scheduling_service: Optional[SchedulingService] = None,
+        stalled_ticket_timeout: Optional[int] = 60,
     ):
         self.agent_service = agent_service
         self.routing_service = routing_service
@@ -4463,11 +5190,37 @@ class QueryProcessor:
         self.require_human_approval = require_human_approval
         self._shutdown_event = asyncio.Event()
         self.scheduling_service = scheduling_service
+        self.stalled_ticket_timeout = stalled_ticket_timeout
+
+        self._stalled_ticket_task = None
+
+        # Start background task for stalled ticket detection if not already running
+        if self.stalled_ticket_timeout is not None and self._stalled_ticket_task is None:
+            try:
+                self._stalled_ticket_task = asyncio.create_task(
+                    self._run_stalled_ticket_checks())
+            except RuntimeError:
+                # No running event loop - likely in test environment
+                pass
 
     async def process(
         self, user_id: str, user_text: str, timezone: str = None
     ) -> AsyncGenerator[str, None]:
         """Process the user request with appropriate agent and handle ticket management."""
+        # Start background task for stalled ticket detection if not already running
+        if self.stalled_ticket_timeout is not None and self._stalled_ticket_task is None:
+            try:
+                loop = asyncio.get_running_loop()
+                self._stalled_ticket_task = loop.create_task(
+                    self._run_stalled_ticket_checks())
+            except RuntimeError:
+                # No running event loop - likely in test environment
+                # Instead of just passing, log a message for clarity
+                import logging
+                logging.warning(
+                    "No running event loop available for stalled ticket checker.")
+                # Don't try to create the task - this prevents the coroutine warning
+
         try:
             # Handle human agent messages differently
             if await self._is_human_agent(user_id):
@@ -4515,7 +5268,9 @@ class QueryProcessor:
         except Exception as e:
             print(f"Error in request processing: {str(e)}")
             print(traceback.format_exc())
-            yield "\n\nI apologize for the technical difficulty.\n\n"
+            # Use yield instead of direct function calling to avoid coroutine warning
+            error_msg = "\n\nI apologize for the technical difficulty.\n\n"
+            yield error_msg
 
     async def _is_human_agent(self, user_id: str) -> bool:
         """Check if the user is a registered human agent."""
@@ -4583,6 +5338,69 @@ class QueryProcessor:
 
         return response
 
+    async def shutdown(self):
+        """Clean shutdown of the query processor."""
+        self._shutdown_event.set()
+
+        # Cancel the stalled ticket task if running
+        if hasattr(self, '_stalled_ticket_task') and self._stalled_ticket_task is not None:
+            self._stalled_ticket_task.cancel()
+            try:
+                await self._stalled_ticket_task
+            except (asyncio.CancelledError, TypeError):
+                # Either properly cancelled coroutine or a mock that can't be awaited
+                pass
+
+    async def _run_stalled_ticket_checks(self):
+        """Run periodic checks for stalled tickets."""
+        try:
+            while not self._shutdown_event.is_set():
+                await self._check_for_stalled_tickets()
+                # Check every 5 minutes or half the timeout period, whichever is smaller
+                check_interval = min(
+                    300, self.stalled_ticket_timeout * 30) if self.stalled_ticket_timeout else 300
+                await asyncio.sleep(check_interval)
+        except asyncio.CancelledError:
+            # Task was cancelled, clean exit
+            pass
+        except Exception as e:
+            print(f"Error in stalled ticket check: {e}")
+
+    async def _check_for_stalled_tickets(self):
+        """Check for tickets that haven't been updated in a while and reassign them."""
+        # If stalled ticket detection is disabled, exit early
+        if self.stalled_ticket_timeout is None:
+            return
+
+        # Find tickets that haven't been updated in the configured time
+        stalled_cutoff = datetime.datetime.now(
+            datetime.timezone.utc) - datetime.timedelta(minutes=self.stalled_ticket_timeout)
+
+        # Query for stalled tickets using the find_stalled_tickets method
+        stalled_tickets = await self.ticket_service.ticket_repository.find_stalled_tickets(
+            stalled_cutoff, [TicketStatus.ACTIVE, TicketStatus.TRANSFERRED]
+        )
+
+        for ticket in stalled_tickets:
+            # Re-route using routing service to find the optimal agent
+            new_agent = await self.routing_service.route_query(ticket.query)
+
+            # Skip if the routing didn't change
+            if new_agent == ticket.assigned_to:
+                continue
+
+            # Process as handoff
+            await self.handoff_service.process_handoff(
+                ticket.id,
+                ticket.assigned_to or "unassigned",
+                new_agent,
+                f"Automatically reassigned after {self.stalled_ticket_timeout} minutes of inactivity"
+            )
+
+            # Log the reassignment
+            print(
+                f"Stalled ticket {ticket.id} reassigned from {ticket.assigned_to or 'unassigned'} to {new_agent}")
+
     async def _process_system_commands(
         self, user_id: str, user_text: str
     ) -> Optional[str]:
@@ -4607,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."
@@ -4619,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
                 )
 
@@ -4634,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:
@@ -4739,154 +5584,530 @@ class QueryProcessor:
                 )
                 return f"Project {ticket_id} has been {'approved' if approved else 'rejected'}."
 
-        elif command == "!schedule" and args and self.scheduling_service:
-            # Format: !schedule task_id [agent_id] [YYYY-MM-DD HH:MM]
-            parts = args.strip().split(" ", 2)
-            if len(parts) < 1:
-                return "Usage: !schedule task_id [agent_id] [YYYY-MM-DD HH:MM]"
-
-            task_id = parts[0]
-            agent_id = parts[1] if len(parts) > 1 else None
-            time_str = parts[2] if len(parts) > 2 else None
-
-            # Fetch the task from ticket repository
-            ticket = self.ticket_service.ticket_repository.get_by_id(task_id)
-            if not ticket:
-                return f"Task {task_id} not found."
-
-            # Convert ticket to scheduled task
-            scheduled_task = ScheduledTask(
-                task_id=task_id,
-                title=ticket.query[:50] +
-                "..." if len(ticket.query) > 50 else ticket.query,
-                description=ticket.query,
-                estimated_minutes=ticket.complexity.get(
-                    "estimated_minutes", 30) if ticket.complexity else 30,
-                priority=5,  # Default priority
-                assigned_to=agent_id or ticket.assigned_to,
-                # Use current agent as a specialization tag
-                specialization_tags=[ticket.assigned_to],
-            )
+            elif command == "!schedule" and args and self.scheduling_service:
+                # Format: !schedule task_id [agent_id] [YYYY-MM-DD HH:MM]
+                parts = args.strip().split(" ", 2)
+                if len(parts) < 1:
+                    return "Usage: !schedule task_id [agent_id] [YYYY-MM-DD HH:MM]"
+
+                task_id = parts[0]
+                agent_id = parts[1] if len(parts) > 1 else None
+                time_str = parts[2] if len(parts) > 2 else None
+
+                # Fetch the task from ticket repository
+                ticket = self.ticket_service.ticket_repository.get_by_id(
+                    task_id)
+                if not ticket:
+                    return f"Task {task_id} not found."
+
+                # Convert ticket to scheduled task
+                scheduled_task = ScheduledTask(
+                    task_id=task_id,
+                    title=ticket.query[:50] +
+                    "..." if len(ticket.query) > 50 else ticket.query,
+                    description=ticket.query,
+                    estimated_minutes=ticket.complexity.get(
+                        "estimated_minutes", 30) if ticket.complexity else 30,
+                    priority=5,  # Default priority
+                    assigned_to=agent_id or ticket.assigned_to,
+                    # Use current agent as a specialization tag
+                    specialization_tags=[ticket.assigned_to],
+                )
 
-            # Set scheduled time if provided
-            if time_str:
-                try:
-                    scheduled_time = datetime.datetime.fromisoformat(time_str)
-                    scheduled_task.scheduled_start = scheduled_time
-                    scheduled_task.scheduled_end = scheduled_time + datetime.timedelta(
-                        minutes=scheduled_task.estimated_minutes
-                    )
-                except ValueError:
-                    return "Invalid date format. Use YYYY-MM-DD HH:MM."
+                # Set scheduled time if provided
+                if time_str:
+                    try:
+                        scheduled_time = datetime.datetime.fromisoformat(
+                            time_str)
+                        scheduled_task.scheduled_start = scheduled_time
+                        scheduled_task.scheduled_end = scheduled_time + datetime.timedelta(
+                            minutes=scheduled_task.estimated_minutes
+                        )
+                    except ValueError:
+                        return "Invalid date format. Use YYYY-MM-DD HH:MM."
 
-            # Schedule the task
-            result = await self.scheduling_service.schedule_task(
-                scheduled_task, preferred_agent_id=agent_id
-            )
+                # Schedule the task
+                result = await self.scheduling_service.schedule_task(
+                    scheduled_task, preferred_agent_id=agent_id
+                )
 
-            # Update ticket with scheduling info
-            self.ticket_service.update_ticket_status(
-                task_id,
-                ticket.status,
-                scheduled_start=result.scheduled_start,
-                scheduled_agent=result.assigned_to
-            )
+                # Update ticket with scheduling info
+                self.ticket_service.update_ticket_status(
+                    task_id,
+                    ticket.status,
+                    scheduled_start=result.scheduled_start,
+                    scheduled_agent=result.assigned_to
+                )
 
-            # Format response
-            response = "# Task Scheduled\n\n"
-            response += f"**Task:** {scheduled_task.title}\n"
-            response += f"**Assigned to:** {result.assigned_to}\n"
-            response += f"**Scheduled start:** {result.scheduled_start.strftime('%Y-%m-%d %H:%M')}\n"
-            response += f"**Estimated duration:** {result.estimated_minutes} minutes"
+                # Format response
+                response = "# Task Scheduled\n\n"
+                response += f"**Task:** {scheduled_task.title}\n"
+                response += f"**Assigned to:** {result.assigned_to}\n"
+                response += f"**Scheduled start:** {result.scheduled_start.strftime('%Y-%m-%d %H:%M')}\n"
+                response += f"**Estimated duration:** {result.estimated_minutes} minutes"
 
-            return response
+                return response
 
-        elif command == "!timeoff" and args and self.scheduling_service:
-            # Format: !timeoff request YYYY-MM-DD HH:MM YYYY-MM-DD HH:MM reason
-            # or: !timeoff cancel request_id
-            parts = args.strip().split(" ", 1)
-            if len(parts) < 2:
-                return "Usage: \n- !timeoff request START_DATE END_DATE reason\n- !timeoff cancel request_id"
+            elif command == "!timeoff" and args and self.scheduling_service:
+                # Format: !timeoff request YYYY-MM-DD HH:MM YYYY-MM-DD HH:MM reason
+                # or: !timeoff cancel request_id
+                parts = args.strip().split(" ", 1)
+                if len(parts) < 2:
+                    return "Usage: \n- !timeoff request START_DATE END_DATE reason\n- !timeoff cancel request_id"
 
-            action = parts[0].lower()
-            action_args = parts[1]
+                action = parts[0].lower()
+                action_args = parts[1]
 
-            if action == "request":
-                # Parse request args
-                request_parts = action_args.split(" ", 2)
-                if len(request_parts) < 3:
-                    return "Usage: !timeoff request YYYY-MM-DD YYYY-MM-DD reason"
+                if action == "request":
+                    # Parse request args
+                    request_parts = action_args.split(" ", 2)
+                    if len(request_parts) < 3:
+                        return "Usage: !timeoff request YYYY-MM-DD YYYY-MM-DD reason"
 
-                start_str = request_parts[0]
-                end_str = request_parts[1]
-                reason = request_parts[2]
+                    start_str = request_parts[0]
+                    end_str = request_parts[1]
+                    reason = request_parts[2]
 
-                try:
-                    start_time = datetime.datetime.fromisoformat(start_str)
-                    end_time = datetime.datetime.fromisoformat(end_str)
-                except ValueError:
-                    return "Invalid date format. Use YYYY-MM-DD HH:MM."
-
-                # Submit time off request
-                success, status, request_id = await self.scheduling_service.request_time_off(
-                    user_id, start_time, end_time, reason
-                )
+                    try:
+                        start_time = datetime.datetime.fromisoformat(start_str)
+                        end_time = datetime.datetime.fromisoformat(end_str)
+                    except ValueError:
+                        return "Invalid date format. Use YYYY-MM-DD HH:MM."
+
+                    # Submit time off request
+                    success, status, request_id = await self.scheduling_service.request_time_off(
+                        user_id, start_time, end_time, reason
+                    )
 
-                if success:
-                    return f"Time off request submitted and automatically approved. Request ID: {request_id}"
-                else:
-                    return f"Time off request {status}. Request ID: {request_id}"
+                    if success:
+                        return f"Time off request submitted and automatically approved. Request ID: {request_id}"
+                    else:
+                        return f"Time off request {status}. Request ID: {request_id}"
+
+                elif action == "cancel":
+                    request_id = action_args.strip()
+                    success, status = await self.scheduling_service.cancel_time_off_request(
+                        user_id, request_id
+                    )
+
+                    if success:
+                        return f"Time off request {request_id} cancelled successfully."
+                    else:
+                        return f"Failed to cancel request: {status}"
+
+                return "Unknown timeoff action. Use 'request' or 'cancel'."
+
+            elif command == "!schedule-view" and self.scheduling_service:
+                # View agent's schedule for the next week
+                # Default to current user if no agent specified
+                agent_id = args.strip() if args else user_id
+
+                start_time = datetime.datetime.now(datetime.timezone.utc)
+                end_time = start_time + datetime.timedelta(days=7)
 
-            elif action == "cancel":
-                request_id = action_args.strip()
-                success, status = await self.scheduling_service.cancel_time_off_request(
-                    user_id, request_id
+                # Get tasks for the specified time period
+                tasks = await self.scheduling_service.get_agent_tasks(
+                    agent_id, start_time, end_time, include_completed=False
                 )
 
-                if success:
-                    return f"Time off request {request_id} cancelled successfully."
-                else:
-                    return f"Failed to cancel request: {status}"
+                if not tasks:
+                    return f"No scheduled tasks found for {agent_id} in the next 7 days."
 
-            return "Unknown timeoff action. Use 'request' or 'cancel'."
+                # Sort by start time
+                tasks.sort(
+                    key=lambda t: t.scheduled_start or datetime.datetime.max)
 
-        elif command == "!schedule-view" and self.scheduling_service:
-            # View agent's schedule for the next week
-            # Default to current user if no agent specified
-            agent_id = args.strip() if args else user_id
+                # Format response
+                response = f"# Schedule for {agent_id}\n\n"
 
-            start_time = datetime.datetime.now(datetime.timezone.utc)
-            end_time = start_time + datetime.timedelta(days=7)
+                current_day = None
+                for task in tasks:
+                    # Group by day
+                    task_day = task.scheduled_start.strftime(
+                        "%Y-%m-%d") if task.scheduled_start else "Unscheduled"
 
-            # Get tasks for the specified time period
-            tasks = await self.scheduling_service.get_agent_tasks(
-                agent_id, start_time, end_time, include_completed=False
-            )
+                    if task_day != current_day:
+                        response += f"\n## {task_day}\n\n"
+                        current_day = task_day
 
-            if not tasks:
-                return f"No scheduled tasks found for {agent_id} in the next 7 days."
+                    start_time = task.scheduled_start.strftime(
+                        "%H:%M") if task.scheduled_start else "TBD"
+                    response += f"- **{start_time}** ({task.estimated_minutes} min): {task.title}\n"
 
-            # Sort by start time
-            tasks.sort(key=lambda t: t.scheduled_start or datetime.datetime.max)
+                return response
 
-            # Format response
-            response = f"# Schedule for {agent_id}\n\n"
+            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"
 
-            current_day = None
-            for task in tasks:
-                # Group by day
-                task_day = task.scheduled_start.strftime(
-                    "%Y-%m-%d") if task.scheduled_start else "Unscheduled"
+                    return response
 
-                if task_day != current_day:
-                    response += f"\n## {task_day}\n\n"
-                    current_day = task_day
+                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"
 
-                start_time = task.scheduled_start.strftime(
-                    "%H:%M") if task.scheduled_start else "TBD"
-                response += f"- **{start_time}** ({task.estimated_minutes} min): {task.title}\n"
+                    return response
 
-            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
 
@@ -5589,7 +6810,8 @@ class SolanaAgentFactory:
             project_approval_service=project_approval_service,
             project_simulation_service=project_simulation_service,
             require_human_approval=config.get("require_human_approval", False),
-            scheduling_service=scheduling_service
+            scheduling_service=scheduling_service,
+            stalled_ticket_timeout=config.get("stalled_ticket_timeout", 60),
         )
 
         return query_processor
@@ -5876,6 +7098,22 @@ class TenantManager:
             llm_provider, task_planning_service, ticket_repo
         )
 
+        # Create scheduling repository and service
+        tenant_db_adapter = self._create_tenant_db_adapter(
+            tenant)  # Get the DB adapter properly
+        scheduling_repository = SchedulingRepository(
+            tenant_db_adapter)  # Use the correct adapter
+
+        scheduling_service = SchedulingService(
+            scheduling_repository=scheduling_repository,
+            task_planning_service=task_planning_service,
+            agent_service=agent_service
+        )
+
+        # Update task_planning_service with scheduling_service if needed
+        if task_planning_service:
+            task_planning_service.scheduling_service = scheduling_service
+
         # Create query processor
         return QueryProcessor(
             agent_service=agent_service,
@@ -5895,6 +7133,9 @@ class TenantManager:
             require_human_approval=tenant.get_config_value(
                 "require_human_approval", False
             ),
+            scheduling_service=scheduling_service,
+            stalled_ticket_timeout=tenant.get_config_value(
+                "stalled_ticket_timeout"),
         )
 
     def _deep_merge(self, target: Dict, source: Dict) -> None: