feat (intent): added gcal intent

Author: itsskofficial

src/model/app/app.py

@@ -57,6 +57,7 @@
 
 from model.context.gmail import GmailContextEngine
 from model.context.internet import InternetSearchContextEngine
+from model.context.gcalendar import GCalendarContextEngine
 
 # Load environment variables from .env file
 load_dotenv("model/.env")
@@ -519,13 +520,15 @@ async def startup_event():
     asyncio.create_task(cleanup_tasks_periodically())
 
     user_id = "user1"  # Replace with dynamic user ID retrieval if needed
-    enabled_data_sources = ["gmail", "internet_search"]  # Add internet_search here
+    enabled_data_sources = ["gmail", "internet_search", "gcalendar"]  # Add gcalendar here
 
     for source in enabled_data_sources:
         if source == "gmail":
             engine = GmailContextEngine(user_id, task_queue, memory_backend, manager, db_lock)
         elif source == "internet_search":
             engine = InternetSearchContextEngine(user_id, task_queue, memory_backend, manager, db_lock)
+        elif source == "gcalendar":
+            engine = GCalendarContextEngine(user_id, task_queue, memory_backend, manager, db_lock)
         else:
             continue  # Skip unrecognized sources
         asyncio.create_task(engine.start())

src/model/context/formats.py

@@ -60,4 +60,51 @@
   },
   "additionalProperties": False,
   "description": "JSON format for only messages"
+}
+
+gcalendar_context_engine_required_format = {
+    "type": "object",
+    "properties": {
+        "tasks": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "description": {
+                        "type": "string",
+                        "description": "Description of the task"
+                    },
+                    "priority": {
+                        "type": "integer",
+                        "description": "Priority of the task",
+                        "enum": [0, 1, 2]
+                    }
+                },
+                "required": ["description", "priority"],
+                "additionalProperties": False
+            },
+            "description": "List of tasks"
+        },
+        "memory_operations": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "text": {
+                        "type": "string",
+                        "description": "Text for memory operation"
+                    }
+                },
+                "required": ["text"],
+                "additionalProperties": False
+            },
+            "description": "List of memory operations"
+        },
+        "message": {
+            "type": "string",
+            "description": "Message to the user"
+        }
+    },
+    "additionalProperties": False,
+    "description": "JSON format for tasks, memory operations, and message"
 }

src/model/context/gcalendar.py

@@ -0,0 +1,86 @@
+from model.context.base import BaseContextEngine
+from model.agents.functions import authenticate_gcalendar
+from model.context.runnables import get_gcalendar_context_runnable
+from datetime import datetime, timedelta
+from dateutil import parser
+import asyncio
+
+class GCalendarContextEngine(BaseContextEngine):
+    """Context Engine for processing Google Calendar data."""
+
+    def __init__(self, *args, **kwargs):
+        print("GCalendarContextEngine.__init__ started")
+        super().__init__(*args, **kwargs)
+        print("GCalendarContextEngine.__init__ - calling authenticate_gcalendar()")
+        self.gcalendar_service = authenticate_gcalendar()
+        print("GCalendarContextEngine.__init__ - gcalendar_service authenticated")
+        self.category = "gcalendar"
+        print(f"GCalendarContextEngine.__init__ - category set to: {self.category}")
+        print("GCalendarContextEngine.__init__ finished")
+
+    async def start(self):
+        """Start the engine, running periodically every hour."""
+        print("GCalendarContextEngine.start started")
+        while True:
+            print("GCalendarContextEngine.start - running engine iteration")
+            await self.run_engine()
+            print("GCalendarContextEngine.start - engine iteration finished, sleeping for 3600 seconds")
+            await asyncio.sleep(3600)  # Check every hour
+
+    async def fetch_new_data(self):
+        """Fetch upcoming events from Google Calendar for the next 24 hours."""
+        print("GCalendarContextEngine.fetch_new_data started")
+        now = datetime.utcnow().isoformat() + "Z"
+        time_max = (datetime.utcnow() + timedelta(days=1)).isoformat() + "Z"
+        print(f"GCalendarContextEngine.fetch_new_data - fetching events from {now} to {time_max}")
+        events_result = self.gcalendar_service.events().list(
+            calendarId="primary",
+            timeMin=now,
+            timeMax=time_max,
+            maxResults=10,
+            singleEvents=True,
+            orderBy="startTime"
+        ).execute()
+        events = events_result.get("items", [])
+        print(f"GCalendarContextEngine.fetch_new_data - fetched {len(events)} events")
+        
+        # Update context with the last fetch time
+        self.context["gcalendar"] = self.context.get("gcalendar", {})
+        self.context["gcalendar"]["last_fetched"] = now
+        print("GCalendarContextEngine.fetch_new_data - saving context")
+        await self.save_context()
+        print(f"GCalendarContextEngine.fetch_new_data - returning {len(events)} events")
+        print("GCalendarContextEngine.fetch_new_data finished")
+        return events
+
+    async def process_new_data(self, new_events):
+        """Process new calendar events into summaries."""
+        print("GCalendarContextEngine.process_new_data started")
+        print(f"GCalendarContextEngine.process_new_data - processing {len(new_events)} new events")
+        summaries = []
+        for event in new_events:
+            event_summary = event.get("summary", "No title")
+            start_time = parser.parse(event["start"].get("dateTime", event["start"].get("date")))
+            start_time_str = start_time.strftime("%Y-%m-%d %H:%M")
+            summary = f"You have an event '{event_summary}' at {start_time_str}"
+            summaries.append(summary)
+            print(f"GCalendarContextEngine.process_new_data - generated summary: {summary}")
+        joined_summaries = "\n".join(summaries)
+        print(f"GCalendarContextEngine.process_new_data - joined summaries: {joined_summaries}")
+        print("GCalendarContextEngine.process_new_data finished")
+        return joined_summaries
+
+    async def get_runnable(self):
+        """Return the GCalendar-specific runnable."""
+        print("GCalendarContextEngine.get_runnable started")
+        runnable = get_gcalendar_context_runnable()
+        print(f"GCalendarContextEngine.get_runnable - returning runnable: {runnable}")
+        print("GCalendarContextEngine.get_runnable finished")
+        return runnable
+
+    async def get_category(self):
+        """Return the memory category for GCalendar."""
+        print("GCalendarContextEngine.get_category started")
+        print(f"GCalendarContextEngine.get_category - returning category: {self.category}")
+        print("GCalendarContextEngine.get_category finished")
+        return self.category

src/model/context/prompts.py

@@ -84,4 +84,53 @@
 Chat History:
 {chat_history}
 
-Generate the appropriate messages based on the above information."""
+Generate the appropriate messages based on the above information."""
+
+gcalendar_context_engine_system_prompt_template = """You are the Context Engine for Google Calendar, responsible for processing upcoming event information and generating appropriate tasks, memory operations, and messages for the user.
+
+You will receive the following inputs:
+
+- New information: Summaries of upcoming events from Google Calendar.
+- Related memories: Existing memories related to Google Calendar.
+- Ongoing tasks: Current tasks in the task queue.
+- Chat history: Recent chat messages with the user.
+
+Based on this, generate:
+
+- Tasks to do: New tasks the user might need to perform based on the upcoming events (e.g., prepare for a meeting, buy a gift for a birthday).
+- Memory operations: Add, update, or delete memories based on the events (e.g., remember a meeting time, update event details).
+- Message: A message to send to the user to inform them about the upcoming events or remind them of tasks.
+
+Consider the user's current context, ongoing tasks, and chat history to make relevant suggestions.
+
+Output a JSON object with the following structure:
+{
+  "tasks": [
+    {
+      "description": "Task description",
+      "priority": 1
+    }
+  ],
+  "memory_operations": [
+    {
+      "text": "Memory text"
+    }
+  ],
+  "message": "Message to the user"
+}
+
+Only include sections that have items. If there are no tasks, memory operations, or message, omit those fields."""
+
+gcalendar_context_engine_user_prompt_template = """Upcoming Event Summaries:
+{new_information}
+
+Related Memories:
+{related_memories}
+
+Ongoing Tasks:
+{ongoing_tasks}
+
+Chat History:
+{chat_history}
+
+Generate the appropriate tasks, memory operations, and message based on the above information."""

src/model/context/runnables.py

@@ -55,4 +55,30 @@ def get_internet_search_context_runnable():
         required_format=internet_search_context_engine_required_format,
         response_type="json",
         stateful=False,
+    )
+
+def get_gcalendar_context_runnable():
+    """Configure and return a Runnable for the GCalendar Context Engine."""
+    model_mapping = {
+        "openai": (os.getenv("OPENAI_API_URL"), OpenAIRunnable),
+        "claude": (os.getenv("CLAUDE_API_URL"), ClaudeRunnable),
+        "gemini": (os.getenv("GEMINI_API_URL"), GeminiRunnable),
+    }
+    model_name, provider = get_selected_model()  # Assume this function exists
+
+    if provider and provider in model_mapping:
+        model_url, runnable_class = model_mapping[provider]
+    else:
+        model_url = os.getenv("BASE_MODEL_URL")
+        runnable_class = OllamaRunnable  # Default fallback, adjust as needed
+
+    return runnable_class(
+        model_url=model_url,
+        model_name=model_name,
+        system_prompt_template=gcalendar_context_engine_system_prompt_template,
+        user_prompt_template=gcalendar_context_engine_user_prompt_template,
+        input_variables=["new_information", "related_memories", "ongoing_tasks", "chat_history"],
+        required_format=gcalendar_context_engine_required_format,
+        response_type="json",
+        stateful=False,
     )