khoj 1.24.2.dev3__py3-none-any.whl → 1.25.1.dev34__py3-none-any.whl

khoj/routers/api_content.py

@@ -2,11 +2,13 @@ import asyncio
 import json
 import logging
 import math
+from concurrent.futures import ThreadPoolExecutor
 from typing import Dict, List, Optional, Union
 
 from asgiref.sync import sync_to_async
 from fastapi import (
     APIRouter,
+    BackgroundTasks,
     Depends,
     Header,
     HTTPException,
@@ -58,6 +60,8 @@ logger = logging.getLogger(__name__)
 
 api_content = APIRouter()
 
+executor = ThreadPoolExecutor()
+
 
 class File(BaseModel):
     path: str
@@ -77,6 +81,11 @@ class IndexerInput(BaseModel):
     docx: Optional[dict[str, bytes]] = None
 
 
+async def run_in_executor(func, *args):
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(executor, func, *args)
+
+
 @api_content.put("")
 @requires(["authenticated"])
 async def put_content(
@@ -209,6 +218,7 @@ async def set_content_github(
 @requires(["authenticated"])
 async def set_content_notion(
     request: Request,
+    background_tasks: BackgroundTasks,
     updated_config: Union[NotionContentConfig, None],
     client: Optional[str] = None,
 ):
@@ -225,6 +235,10 @@ async def set_content_notion(
         logger.error(e, exc_info=True)
         raise HTTPException(status_code=500, detail="Failed to set Notion config")
 
+    if updated_config.token:
+        # Trigger an async job to configure_content. Let it run without blocking the response.
+        background_tasks.add_task(run_in_executor, configure_content, {}, False, SearchType.Notion, user)
+
     update_telemetry_state(
         request=request,
         telemetry_type="api",

khoj/routers/api_model.py

@@ -40,7 +40,7 @@ def get_user_chat_model(
     chat_model = ConversationAdapters.get_conversation_config(user)
 
     if chat_model is None:
-        chat_model = ConversationAdapters.get_default_conversation_config()
+        chat_model = ConversationAdapters.get_default_conversation_config(user)
 
     return Response(status_code=200, content=json.dumps({"id": chat_model.id, "chat_model": chat_model.chat_model}))
 

khoj/routers/auth.py

@@ -80,11 +80,19 @@ async def login_magic_link(request: Request, form: MagicLinkForm):
         request.session.pop("user", None)
 
     email = form.email
-    user = await aget_or_create_user_by_email(email)
+    user, is_new = await aget_or_create_user_by_email(email)
     unique_id = user.email_verification_code
 
     if user:
         await send_magic_link_email(email, unique_id, request.base_url)
+        if is_new:
+            update_telemetry_state(
+                request=request,
+                telemetry_type="api",
+                api="create_user",
+                metadata={"user_id": str(user.uuid)},
+            )
+            logger.log(logging.INFO, f"🥳 New User Created: {user.uuid}")
 
     return Response(status_code=200)
 

khoj/routers/helpers.py

@@ -39,6 +39,7 @@ from khoj.database.adapters import (
     AutomationAdapters,
     ConversationAdapters,
     EntryAdapters,
+    ais_user_subscribed,
     create_khoj_token,
     get_khoj_tokens,
     get_user_name,
@@ -47,6 +48,7 @@ from khoj.database.adapters import (
     run_with_process_lock,
 )
 from khoj.database.models import (
+    Agent,
     ChatModelOptions,
     ClientApplication,
     Conversation,
@@ -118,20 +120,20 @@ def is_query_empty(query: str) -> bool:
     return is_none_or_empty(query.strip())
 
 
-def validate_conversation_config():
-    default_config = ConversationAdapters.get_default_conversation_config()
+def validate_conversation_config(user: KhojUser):
+    default_config = ConversationAdapters.get_default_conversation_config(user)
 
     if default_config is None:
-        raise HTTPException(status_code=500, detail="Contact the server administrator to set a default chat model.")
+        raise HTTPException(status_code=500, detail="Contact the server administrator to add a chat model.")
 
     if default_config.model_type == "openai" and not default_config.openai_config:
-        raise HTTPException(status_code=500, detail="Contact the server administrator to set a default chat model.")
+        raise HTTPException(status_code=500, detail="Contact the server administrator to add a chat model.")
 
 
 async def is_ready_to_chat(user: KhojUser):
-    user_conversation_config = (await ConversationAdapters.aget_user_conversation_config(user)) or (
-        await ConversationAdapters.aget_default_conversation_config()
-    )
+    user_conversation_config = await ConversationAdapters.aget_user_conversation_config(user)
+    if user_conversation_config == None:
+        user_conversation_config = await ConversationAdapters.aget_default_conversation_config()
 
     if user_conversation_config and user_conversation_config.model_type == ChatModelOptions.ModelType.OFFLINE:
         chat_model = user_conversation_config.chat_model
@@ -207,7 +209,7 @@ def get_next_url(request: Request) -> str:
 def construct_chat_history(conversation_history: dict, n: int = 4, agent_name="AI") -> str:
     chat_history = ""
     for chat in conversation_history.get("chat", [])[-n:]:
-        if chat["by"] == "khoj" and chat["intent"].get("type") in ["remember", "reminder"]:
+        if chat["by"] == "khoj" and chat["intent"].get("type") in ["remember", "reminder", "summarize"]:
             chat_history += f"User: {chat['intent']['query']}\n"
             chat_history += f"{agent_name}: {chat['message']}\n"
         elif chat["by"] == "khoj" and ("text-to-image" in chat["intent"].get("type")):
@@ -245,20 +247,51 @@ async def agenerate_chat_response(*args):
     return await loop.run_in_executor(executor, generate_chat_response, *args)
 
 
-async def acreate_title_from_query(query: str) -> str:
+async def acreate_title_from_query(query: str, user: KhojUser = None) -> str:
     """
     Create a title from the given query
     """
     title_generation_prompt = prompts.subject_generation.format(query=query)
 
     with timer("Chat actor: Generate title from query", logger):
-        response = await send_message_to_model_wrapper(title_generation_prompt)
+        response = await send_message_to_model_wrapper(title_generation_prompt, user=user)
 
     return response.strip()
 
 
+async def acheck_if_safe_prompt(system_prompt: str, user: KhojUser = None) -> Tuple[bool, str]:
+    """
+    Check if the system prompt is safe to use
+    """
+    safe_prompt_check = prompts.personality_prompt_safety_expert.format(prompt=system_prompt)
+    is_safe = True
+    reason = ""
+
+    with timer("Chat actor: Check if safe prompt", logger):
+        response = await send_message_to_model_wrapper(safe_prompt_check, user=user)
+
+        response = response.strip()
+        try:
+            response = json.loads(response)
+            is_safe = response.get("safe", "True") == "True"
+            if not is_safe:
+                reason = response.get("reason", "")
+        except Exception:
+            logger.error(f"Invalid response for checking safe prompt: {response}")
+
+    if not is_safe:
+        logger.error(f"Unsafe prompt: {system_prompt}. Reason: {reason}")
+
+    return is_safe, reason
+
+
 async def aget_relevant_information_sources(
-    query: str, conversation_history: dict, is_task: bool, subscribed: bool, uploaded_image_url: str = None
+    query: str,
+    conversation_history: dict,
+    is_task: bool,
+    user: KhojUser,
+    uploaded_image_url: str = None,
+    agent: Agent = None,
 ):
     """
     Given a query, determine which of the available tools the agent should use in order to answer appropriately.
@@ -267,26 +300,34 @@ async def aget_relevant_information_sources(
     tool_options = dict()
     tool_options_str = ""
 
+    agent_tools = agent.input_tools if agent else []
+
     for tool, description in tool_descriptions_for_llm.items():
         tool_options[tool.value] = description
-        tool_options_str += f'- "{tool.value}": "{description}"\n'
+        if len(agent_tools) == 0 or tool.value in agent_tools:
+            tool_options_str += f'- "{tool.value}": "{description}"\n'
 
     chat_history = construct_chat_history(conversation_history)
 
     if uploaded_image_url:
         query = f"[placeholder for user attached image]\n{query}"
 
+    personality_context = (
+        prompts.personality_context.format(personality=agent.personality) if agent and agent.personality else ""
+    )
+
     relevant_tools_prompt = prompts.pick_relevant_information_collection_tools.format(
         query=query,
         tools=tool_options_str,
         chat_history=chat_history,
+        personality_context=personality_context,
     )
 
     with timer("Chat actor: Infer information sources to refer", logger):
         response = await send_message_to_model_wrapper(
             relevant_tools_prompt,
             response_type="json_object",
-            subscribed=subscribed,
+            user=user,
         )
 
     try:
@@ -300,20 +341,34 @@ async def aget_relevant_information_sources(
 
         final_response = [] if not is_task else [ConversationCommand.AutomatedTask]
         for llm_suggested_tool in response:
-            if llm_suggested_tool in tool_options.keys():
+            # Add a double check to verify it's in the agent list, because the LLM sometimes gets confused by the tool options.
+            if llm_suggested_tool in tool_options.keys() and (
+                len(agent_tools) == 0 or llm_suggested_tool in agent_tools
+            ):
                 # Check whether the tool exists as a valid ConversationCommand
                 final_response.append(ConversationCommand(llm_suggested_tool))
 
         if is_none_or_empty(final_response):
-            final_response = [ConversationCommand.Default]
-        return final_response
-    except Exception as e:
+            if len(agent_tools) == 0:
+                final_response = [ConversationCommand.Default]
+            else:
+                final_response = [ConversationCommand.General]
+    except Exception:
         logger.error(f"Invalid response for determining relevant tools: {response}")
-        return [ConversationCommand.Default]
+        if len(agent_tools) == 0:
+            final_response = [ConversationCommand.Default]
+        else:
+            final_response = agent_tools
+    return final_response
 
 
 async def aget_relevant_output_modes(
-    query: str, conversation_history: dict, is_task: bool = False, uploaded_image_url: str = None
+    query: str,
+    conversation_history: dict,
+    is_task: bool = False,
+    user: KhojUser = None,
+    uploaded_image_url: str = None,
+    agent: Agent = None,
 ):
     """
     Given a query, determine which of the available tools the agent should use in order to answer appropriately.
@@ -322,26 +377,34 @@ async def aget_relevant_output_modes(
     mode_options = dict()
     mode_options_str = ""
 
+    output_modes = agent.output_modes if agent else []
+
     for mode, description in mode_descriptions_for_llm.items():
         # Do not allow tasks to schedule another task
         if is_task and mode == ConversationCommand.Automation:
             continue
         mode_options[mode.value] = description
-        mode_options_str += f'- "{mode.value}": "{description}"\n'
+        if len(output_modes) == 0 or mode.value in output_modes:
+            mode_options_str += f'- "{mode.value}": "{description}"\n'
 
     chat_history = construct_chat_history(conversation_history)
 
     if uploaded_image_url:
         query = f"[placeholder for user attached image]\n{query}"
 
+    personality_context = (
+        prompts.personality_context.format(personality=agent.personality) if agent and agent.personality else ""
+    )
+
     relevant_mode_prompt = prompts.pick_relevant_output_mode.format(
         query=query,
         modes=mode_options_str,
         chat_history=chat_history,
+        personality_context=personality_context,
     )
 
     with timer("Chat actor: Infer output mode for chat response", logger):
-        response = await send_message_to_model_wrapper(relevant_mode_prompt, response_type="json_object")
+        response = await send_message_to_model_wrapper(relevant_mode_prompt, response_type="json_object", user=user)
 
     try:
         response = response.strip()
@@ -352,7 +415,9 @@ async def aget_relevant_output_modes(
             return ConversationCommand.Text
 
         output_mode = response["output"]
-        if output_mode in mode_options.keys():
+
+        # Add a double check to verify it's in the agent list, because the LLM sometimes gets confused by the tool options.
+        if output_mode in mode_options.keys() and (len(output_modes) == 0 or output_mode in output_modes):
             # Check whether the tool exists as a valid ConversationCommand
             return ConversationCommand(output_mode)
 
@@ -364,7 +429,12 @@ async def aget_relevant_output_modes(
 
 
 async def infer_webpage_urls(
-    q: str, conversation_history: dict, location_data: LocationData, user: KhojUser, uploaded_image_url: str = None
+    q: str,
+    conversation_history: dict,
+    location_data: LocationData,
+    user: KhojUser,
+    uploaded_image_url: str = None,
+    agent: Agent = None,
 ) -> List[str]:
     """
     Infer webpage links from the given query
@@ -374,17 +444,22 @@ async def infer_webpage_urls(
     chat_history = construct_chat_history(conversation_history)
 
     utc_date = datetime.utcnow().strftime("%Y-%m-%d")
+    personality_context = (
+        prompts.personality_context.format(personality=agent.personality) if agent and agent.personality else ""
+    )
+
     online_queries_prompt = prompts.infer_webpages_to_read.format(
         current_date=utc_date,
         query=q,
         chat_history=chat_history,
         location=location,
         username=username,
+        personality_context=personality_context,
     )
 
     with timer("Chat actor: Infer webpage urls to read", logger):
         response = await send_message_to_model_wrapper(
-            online_queries_prompt, uploaded_image_url=uploaded_image_url, response_type="json_object"
+            online_queries_prompt, uploaded_image_url=uploaded_image_url, response_type="json_object", user=user
         )
 
     # Validate that the response is a non-empty, JSON-serializable list of URLs
@@ -400,7 +475,12 @@ async def infer_webpage_urls(
 
 
 async def generate_online_subqueries(
-    q: str, conversation_history: dict, location_data: LocationData, user: KhojUser, uploaded_image_url: str = None
+    q: str,
+    conversation_history: dict,
+    location_data: LocationData,
+    user: KhojUser,
+    uploaded_image_url: str = None,
+    agent: Agent = None,
 ) -> List[str]:
     """
     Generate subqueries from the given query
@@ -410,17 +490,22 @@ async def generate_online_subqueries(
     chat_history = construct_chat_history(conversation_history)
 
     utc_date = datetime.utcnow().strftime("%Y-%m-%d")
+    personality_context = (
+        prompts.personality_context.format(personality=agent.personality) if agent and agent.personality else ""
+    )
+
     online_queries_prompt = prompts.online_search_conversation_subqueries.format(
         current_date=utc_date,
         query=q,
         chat_history=chat_history,
         location=location,
         username=username,
+        personality_context=personality_context,
     )
 
     with timer("Chat actor: Generate online search subqueries", logger):
         response = await send_message_to_model_wrapper(
-            online_queries_prompt, uploaded_image_url=uploaded_image_url, response_type="json_object"
+            online_queries_prompt, uploaded_image_url=uploaded_image_url, response_type="json_object", user=user
         )
 
     # Validate that the response is a non-empty, JSON-serializable list
@@ -438,7 +523,9 @@ async def generate_online_subqueries(
         return [q]
 
 
-async def schedule_query(q: str, conversation_history: dict, uploaded_image_url: str = None) -> Tuple[str, ...]:
+async def schedule_query(
+    q: str, conversation_history: dict, user: KhojUser, uploaded_image_url: str = None
+) -> Tuple[str, ...]:
     """
     Schedule the date, time to run the query. Assume the server timezone is UTC.
     """
@@ -450,7 +537,7 @@ async def schedule_query(q: str, conversation_history: dict, uploaded_image_url:
     )
 
     raw_response = await send_message_to_model_wrapper(
-        crontime_prompt, uploaded_image_url=uploaded_image_url, response_type="json_object"
+        crontime_prompt, uploaded_image_url=uploaded_image_url, response_type="json_object", user=user
     )
 
     # Validate that the response is a non-empty, JSON-serializable list
@@ -464,33 +551,41 @@ async def schedule_query(q: str, conversation_history: dict, uploaded_image_url:
         raise AssertionError(f"Invalid response for scheduling query: {raw_response}")
 
 
-async def extract_relevant_info(q: str, corpus: str, subscribed: bool) -> Union[str, None]:
+async def extract_relevant_info(
+    qs: set[str], corpus: str, user: KhojUser = None, agent: Agent = None
+) -> Union[str, None]:
     """
     Extract relevant information for a given query from the target corpus
     """
 
-    if is_none_or_empty(corpus) or is_none_or_empty(q):
+    if is_none_or_empty(corpus) or is_none_or_empty(qs):
         return None
 
+    personality_context = (
+        prompts.personality_context.format(personality=agent.personality) if agent and agent.personality else ""
+    )
+
     extract_relevant_information = prompts.extract_relevant_information.format(
-        query=q,
+        query=", ".join(qs),
         corpus=corpus.strip(),
+        personality_context=personality_context,
     )
 
-    chat_model: ChatModelOptions = await ConversationAdapters.aget_default_conversation_config()
-
-    with timer("Chat actor: Extract relevant information from data", logger):
-        response = await send_message_to_model_wrapper(
-            extract_relevant_information,
-            prompts.system_prompt_extract_relevant_information,
-            chat_model_option=chat_model,
-            subscribed=subscribed,
-        )
+    response = await send_message_to_model_wrapper(
+        extract_relevant_information,
+        prompts.system_prompt_extract_relevant_information,
+        user=user,
+    )
     return response.strip()
 
 
 async def extract_relevant_summary(
-    q: str, corpus: str, subscribed: bool = False, uploaded_image_url: str = None
+    q: str,
+    corpus: str,
+    conversation_history: dict,
+    uploaded_image_url: str = None,
+    user: KhojUser = None,
+    agent: Agent = None,
 ) -> Union[str, None]:
     """
     Extract relevant information for a given query from the target corpus
@@ -499,19 +594,24 @@ async def extract_relevant_summary(
     if is_none_or_empty(corpus) or is_none_or_empty(q):
         return None
 
+    personality_context = (
+        prompts.personality_context.format(personality=agent.personality) if agent and agent.personality else ""
+    )
+
+    chat_history = construct_chat_history(conversation_history)
+
     extract_relevant_information = prompts.extract_relevant_summary.format(
         query=q,
+        chat_history=chat_history,
         corpus=corpus.strip(),
+        personality_context=personality_context,
     )
 
-    chat_model: ChatModelOptions = await ConversationAdapters.aget_default_conversation_config()
-
     with timer("Chat actor: Extract relevant information from data", logger):
         response = await send_message_to_model_wrapper(
             extract_relevant_information,
             prompts.system_prompt_extract_relevant_summary,
-            chat_model_option=chat_model,
-            subscribed=subscribed,
+            user=user,
             uploaded_image_url=uploaded_image_url,
         )
     return response.strip()
@@ -524,14 +624,18 @@ async def generate_better_image_prompt(
     note_references: List[Dict[str, Any]],
     online_results: Optional[dict] = None,
     model_type: Optional[str] = None,
-    subscribed: bool = False,
     uploaded_image_url: Optional[str] = None,
+    user: KhojUser = None,
+    agent: Agent = None,
 ) -> str:
     """
     Generate a better image prompt from the given query
     """
 
     today_date = datetime.now(tz=timezone.utc).strftime("%Y-%m-%d, %A")
+    personality_context = (
+        prompts.personality_context.format(personality=agent.personality) if agent and agent.personality else ""
+    )
     model_type = model_type or TextToImageModelConfig.ModelType.OPENAI
 
     if location_data:
@@ -558,6 +662,7 @@ async def generate_better_image_prompt(
             current_date=today_date,
             references=user_references,
             online_results=simplified_online_results,
+            personality_context=personality_context,
         )
     elif model_type in [TextToImageModelConfig.ModelType.STABILITYAI, TextToImageModelConfig.ModelType.REPLICATE]:
         image_prompt = prompts.image_generation_improve_prompt_sd.format(
@@ -567,14 +672,11 @@ async def generate_better_image_prompt(
             current_date=today_date,
             references=user_references,
             online_results=simplified_online_results,
+            personality_context=personality_context,
         )
 
-    chat_model: ChatModelOptions = await ConversationAdapters.aget_default_conversation_config()
-
     with timer("Chat actor: Generate contextual image prompt", logger):
-        response = await send_message_to_model_wrapper(
-            image_prompt, chat_model_option=chat_model, subscribed=subscribed, uploaded_image_url=uploaded_image_url
-        )
+        response = await send_message_to_model_wrapper(image_prompt, uploaded_image_url=uploaded_image_url, user=user)
         response = response.strip()
         if response.startswith(('"', "'")) and response.endswith(('"', "'")):
             response = response[1:-1]
@@ -586,14 +688,10 @@ async def send_message_to_model_wrapper(
     message: str,
     system_message: str = "",
     response_type: str = "text",
-    chat_model_option: ChatModelOptions = None,
-    subscribed: bool = False,
+    user: KhojUser = None,
     uploaded_image_url: str = None,
 ):
-    conversation_config: ChatModelOptions = (
-        chat_model_option or await ConversationAdapters.aget_default_conversation_config()
-    )
-
+    conversation_config: ChatModelOptions = await ConversationAdapters.aget_default_conversation_config(user)
     vision_available = conversation_config.vision_enabled
     if not vision_available and uploaded_image_url:
         vision_enabled_config = await ConversationAdapters.aget_vision_enabled_config()
@@ -601,6 +699,7 @@ async def send_message_to_model_wrapper(
             conversation_config = vision_enabled_config
             vision_available = True
 
+    subscribed = await ais_user_subscribed(user)
     chat_model = conversation_config.chat_model
     max_tokens = (
         conversation_config.subscribed_max_prompt_size
@@ -651,15 +750,13 @@ async def send_message_to_model_wrapper(
             model_type=conversation_config.model_type,
         )
 
-        openai_response = send_message_to_model(
+        return send_message_to_model(
             messages=truncated_messages,
             api_key=api_key,
             model=chat_model,
             response_type=response_type,
             api_base_url=api_base_url,
         )
-
-        return openai_response
     elif model_type == ChatModelOptions.ModelType.ANTHROPIC:
         api_key = conversation_config.openai_config.api_key
         truncated_messages = generate_chatml_messages_with_context(
@@ -701,8 +798,9 @@ def send_message_to_model_wrapper_sync(
     message: str,
     system_message: str = "",
     response_type: str = "text",
+    user: KhojUser = None,
 ):
-    conversation_config: ChatModelOptions = ConversationAdapters.get_default_conversation_config()
+    conversation_config: ChatModelOptions = ConversationAdapters.get_default_conversation_config(user)
 
     if conversation_config is None:
         raise HTTPException(status_code=500, detail="Contact the server administrator to set a default chat model.")
@@ -942,13 +1040,23 @@ class ApiUserRateLimiter:
 
         # Check if the user has exceeded the rate limit
         if subscribed and count_requests >= self.subscribed_requests:
+            logger.info(
+                f"Rate limit: {count_requests} requests in {self.window} seconds for user: {user}. Limit is {self.subscribed_requests} requests."
+            )
             raise HTTPException(status_code=429, detail="Slow down! Too Many Requests")
         if not subscribed and count_requests >= self.requests:
             if self.requests >= self.subscribed_requests:
+                logger.info(
+                    f"Rate limit: {count_requests} requests in {self.window} seconds for user: {user}. Limit is {self.subscribed_requests} requests."
+                )
                 raise HTTPException(
                     status_code=429,
                     detail="Slow down! Too Many Requests",
                 )
+
+            logger.info(
+                f"Rate limit: {count_requests} requests in {self.window} seconds for user: {user}. Limit is {self.subscribed_requests} requests."
+            )
             raise HTTPException(
                 status_code=429,
                 detail="We're glad you're enjoying Khoj! You've exceeded your usage limit for today. Come back tomorrow or subscribe to increase your usage limit via [your settings](https://app.khoj.dev/settings).",
@@ -986,6 +1094,9 @@ class ConversationCommandRateLimiter:
         ).acount()
 
         if subscribed and count_requests >= self.subscribed_rate_limit:
+            logger.info(
+                f"Rate limit: {count_requests} requests in 24 hours for user: {user}. Limit is {self.subscribed_rate_limit} requests."
+            )
             raise HTTPException(status_code=429, detail="Slow down! Too Many Requests")
         if not subscribed and count_requests >= self.trial_rate_limit:
             raise HTTPException(
@@ -1068,7 +1179,7 @@ class CommonQueryParamsClass:
 CommonQueryParams = Annotated[CommonQueryParamsClass, Depends()]
 
 
-def should_notify(original_query: str, executed_query: str, ai_response: str) -> bool:
+def should_notify(original_query: str, executed_query: str, ai_response: str, user: KhojUser) -> bool:
     """
     Decide whether to notify the user of the AI response.
     Default to notifying the user for now.
@@ -1085,7 +1196,7 @@ def should_notify(original_query: str, executed_query: str, ai_response: str) ->
     with timer("Chat actor: Decide to notify user of automation response", logger):
         try:
             # TODO Replace with async call so we don't have to maintain a sync version
-            response = send_message_to_model_wrapper_sync(to_notify_or_not)
+            response = send_message_to_model_wrapper_sync(to_notify_or_not, user)
             should_notify_result = "no" not in response.lower()
             logger.info(f'Decided to {"not " if not should_notify_result else ""}notify user of automation response.')
             return should_notify_result
@@ -1177,7 +1288,9 @@ def scheduled_chat(
         ai_response = raw_response.text
 
     # Notify user if the AI response is satisfactory
-    if should_notify(original_query=scheduling_request, executed_query=cleaned_query, ai_response=ai_response):
+    if should_notify(
+        original_query=scheduling_request, executed_query=cleaned_query, ai_response=ai_response, user=user
+    ):
         if is_resend_enabled():
             send_task_email(user.get_short_name(), user.email, cleaned_query, ai_response, subject, is_image)
         else:
@@ -1187,7 +1300,7 @@ def scheduled_chat(
 async def create_automation(
     q: str, timezone: str, user: KhojUser, calling_url: URL, meta_log: dict = {}, conversation_id: str = None
 ):
-    crontime, query_to_run, subject = await schedule_query(q, meta_log)
+    crontime, query_to_run, subject = await schedule_query(q, meta_log, user)
     job = await schedule_automation(query_to_run, subject, crontime, timezone, q, user, calling_url, conversation_id)
     return job, crontime, query_to_run, subject
 
@@ -1381,9 +1494,9 @@ def get_user_config(user: KhojUser, request: Request, is_detailed: bool = False)
     current_notion_config = get_user_notion_config(user)
     notion_token = current_notion_config.token if current_notion_config else ""
 
-    selected_chat_model_config = (
-        ConversationAdapters.get_conversation_config(user) or ConversationAdapters.get_default_conversation_config()
-    )
+    selected_chat_model_config = ConversationAdapters.get_conversation_config(
+        user
+    ) or ConversationAdapters.get_default_conversation_config(user)
     chat_models = ConversationAdapters.get_conversation_processor_options().all()
     chat_model_options = list()
     for chat_model in chat_models: