khoj 1.42.1.dev8__py3-none-any.whl → 1.42.2.dev1__py3-none-any.whl

khoj/processor/conversation/utils.py

@@ -24,7 +24,13 @@ from pydantic import BaseModel
 from transformers import AutoTokenizer, PreTrainedTokenizer, PreTrainedTokenizerFast
 
 from khoj.database.adapters import ConversationAdapters
-from khoj.database.models import ChatModel, ClientApplication, KhojUser
+from khoj.database.models import (
+    ChatMessageModel,
+    ChatModel,
+    ClientApplication,
+    Intent,
+    KhojUser,
+)
 from khoj.processor.conversation import prompts
 from khoj.processor.conversation.offline.utils import download_model, infer_max_tokens
 from khoj.search_filter.base_filter import BaseFilter
@@ -161,8 +167,8 @@ def construct_iteration_history(
     previous_iterations: List[ResearchIteration],
     previous_iteration_prompt: str,
     query: str = None,
-) -> list[dict]:
-    iteration_history: list[dict] = []
+) -> list[ChatMessageModel]:
+    iteration_history: list[ChatMessageModel] = []
     previous_iteration_messages: list[dict] = []
     for idx, iteration in enumerate(previous_iterations):
         iteration_data = previous_iteration_prompt.format(
@@ -176,46 +182,46 @@ def construct_iteration_history(
 
     if previous_iteration_messages:
         if query:
-            iteration_history.append({"by": "you", "message": query})
+            iteration_history.append(ChatMessageModel(by="you", message=query))
         iteration_history.append(
-            {
-                "by": "khoj",
-                "intent": {"type": "remember", "query": query},
-                "message": previous_iteration_messages,
-            }
+            ChatMessageModel(
+                by="khoj",
+                intent={"type": "remember", "query": query},
+                message=previous_iteration_messages,
+            )
         )
     return iteration_history
 
 
-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", "summarize"]:
-            if chat["intent"].get("inferred-queries"):
-                chat_history += f'{agent_name}: {{"queries": {chat["intent"].get("inferred-queries")}}}\n'
-            chat_history += f"{agent_name}: {chat['message']}\n\n"
-        elif chat["by"] == "khoj" and chat.get("images"):
-            chat_history += f"User: {chat['intent']['query']}\n"
-            chat_history += f"{agent_name}: [generated image redacted for space]\n"
-        elif chat["by"] == "khoj" and ("excalidraw" in chat["intent"].get("type")):
-            chat_history += f"User: {chat['intent']['query']}\n"
-            chat_history += f"{agent_name}: {chat['intent']['inferred-queries'][0]}\n"
-        elif chat["by"] == "you":
-            chat_history += f"User: {chat['message']}\n"
-            raw_query_files = chat.get("queryFiles")
+def construct_chat_history(chat_history: list[ChatMessageModel], n: int = 4, agent_name="AI") -> str:
+    chat_history_str = ""
+    for chat in chat_history[-n:]:
+        if chat.by == "khoj" and chat.intent.type in ["remember", "reminder", "summarize"]:
+            if chat.intent.inferred_queries:
+                chat_history_str += f'{agent_name}: {{"queries": {chat.intent.inferred_queries}}}\n'
+            chat_history_str += f"{agent_name}: {chat.message}\n\n"
+        elif chat.by == "khoj" and chat.images:
+            chat_history_str += f"User: {chat.intent.query}\n"
+            chat_history_str += f"{agent_name}: [generated image redacted for space]\n"
+        elif chat.by == "khoj" and ("excalidraw" in chat.intent.type):
+            chat_history_str += f"User: {chat.intent.query}\n"
+            chat_history_str += f"{agent_name}: {chat.intent.inferred_queries[0]}\n"
+        elif chat.by == "you":
+            chat_history_str += f"User: {chat.message}\n"
+            raw_query_files = chat.queryFiles
             if raw_query_files:
                 query_files: Dict[str, str] = {}
                 for file in raw_query_files:
                     query_files[file["name"]] = file["content"]
 
                 query_file_context = gather_raw_query_files(query_files)
-                chat_history += f"User: {query_file_context}\n"
+                chat_history_str += f"User: {query_file_context}\n"
 
-    return chat_history
+    return chat_history_str
 
 
 def construct_question_history(
-    conversation_log: dict,
+    conversation_log: list[ChatMessageModel],
     include_query: bool = True,
     lookback: int = 6,
     query_prefix: str = "Q",
@@ -226,16 +232,16 @@ def construct_question_history(
     """
     history_parts = ""
     original_query = None
-    for chat in conversation_log.get("chat", [])[-lookback:]:
-        if chat["by"] == "you":
-            original_query = chat.get("message")
+    for chat in conversation_log[-lookback:]:
+        if chat.by == "you":
+            original_query = json.dumps(chat.message)
             history_parts += f"{query_prefix}: {original_query}\n"
-        if chat["by"] == "khoj":
+        if chat.by == "khoj":
             if original_query is None:
                 continue
 
-            message = chat.get("message", "")
-            inferred_queries_list = chat.get("intent", {}).get("inferred-queries")
+            message = chat.message
+            inferred_queries_list = chat.intent.inferred_queries or []
 
             # Ensure inferred_queries_list is a list, defaulting to the original query in a list
             if not inferred_queries_list:
@@ -246,7 +252,7 @@ def construct_question_history(
 
             if include_query:
                 # Ensure 'type' exists and is a string before checking 'to-image'
-                intent_type = chat.get("intent", {}).get("type", "")
+                intent_type = chat.intent.type if chat.intent and chat.intent.type else ""
                 if "to-image" not in intent_type:
                     history_parts += f'{agent_name}: {{"queries": {inferred_queries_list}}}\n'
                     history_parts += f"A: {message}\n\n"
@@ -259,7 +265,7 @@ def construct_question_history(
     return history_parts
 
 
-def construct_chat_history_for_operator(conversation_history: dict, n: int = 6) -> list[AgentMessage]:
+def construct_chat_history_for_operator(conversation_history: List[ChatMessageModel], n: int = 6) -> list[AgentMessage]:
     """
     Construct chat history for operator agent in conversation log.
     Only include last n completed turns (i.e with user and khoj message).
@@ -267,22 +273,22 @@ def construct_chat_history_for_operator(conversation_history: dict, n: int = 6)
     chat_history: list[AgentMessage] = []
     user_message: Optional[AgentMessage] = None
 
-    for chat in conversation_history.get("chat", []):
+    for chat in conversation_history:
         if len(chat_history) >= n:
             break
-        if chat["by"] == "you" and chat.get("message"):
-            content = [{"type": "text", "text": chat["message"]}]
-            for file in chat.get("queryFiles", []):
+        if chat.by == "you" and chat.message:
+            content = [{"type": "text", "text": chat.message}]
+            for file in chat.queryFiles or []:
                 content += [{"type": "text", "text": f'## File: {file["name"]}\n\n{file["content"]}'}]
             user_message = AgentMessage(role="user", content=content)
-        elif chat["by"] == "khoj" and chat.get("message"):
-            chat_history += [user_message, AgentMessage(role="assistant", content=chat["message"])]
+        elif chat.by == "khoj" and chat.message:
+            chat_history += [user_message, AgentMessage(role="assistant", content=chat.message)]
     return chat_history
 
 
 def construct_tool_chat_history(
     previous_iterations: List[ResearchIteration], tool: ConversationCommand = None
-) -> Dict[str, list]:
+) -> List[ChatMessageModel]:
     """
     Construct chat history from previous iterations for a specific tool
 
@@ -313,22 +319,23 @@ def construct_tool_chat_history(
             tool or ConversationCommand(iteration.tool), base_extractor
         )
         chat_history += [
-            {
-                "by": "you",
-                "message": iteration.query,
-            },
-            {
-                "by": "khoj",
-                "intent": {
-                    "type": "remember",
-                    "inferred-queries": inferred_query_extractor(iteration),
-                    "query": iteration.query,
-                },
-                "message": iteration.summarizedResult,
-            },
+            ChatMessageModel(
+                by="you",
+                message=iteration.query,
+            ),
+            ChatMessageModel(
+                by="khoj",
+                intent=Intent(
+                    type="remember",
+                    query=iteration.query,
+                    inferred_queries=inferred_query_extractor(iteration),
+                    memory_type="notes",
+                ),
+                message=iteration.summarizedResult,
+            ),
         ]
 
-    return {"chat": chat_history}
+    return chat_history
 
 
 class ChatEvent(Enum):
@@ -349,8 +356,8 @@ def message_to_log(
     chat_response,
     user_message_metadata={},
     khoj_message_metadata={},
-    conversation_log=[],
-):
+    chat_history: List[ChatMessageModel] = [],
+) -> List[ChatMessageModel]:
     """Create json logs from messages, metadata for conversation log"""
     default_khoj_message_metadata = {
         "intent": {"type": "remember", "memory-type": "notes", "query": user_message},
@@ -369,15 +376,17 @@ def message_to_log(
     khoj_log = merge_dicts(khoj_message_metadata, default_khoj_message_metadata)
     khoj_log = merge_dicts({"message": chat_response, "by": "khoj", "created": khoj_response_time}, khoj_log)
 
-    conversation_log.extend([human_log, khoj_log])
-    return conversation_log
+    human_message = ChatMessageModel(**human_log)
+    khoj_message = ChatMessageModel(**khoj_log)
+    chat_history.extend([human_message, khoj_message])
+    return chat_history
 
 
 async def save_to_conversation_log(
     q: str,
     chat_response: str,
     user: KhojUser,
-    meta_log: Dict,
+    chat_history: List[ChatMessageModel],
     user_message_time: str = None,
     compiled_references: List[Dict[str, Any]] = [],
     online_results: Dict[str, Any] = {},
@@ -427,11 +436,11 @@ async def save_to_conversation_log(
         chat_response=chat_response,
         user_message_metadata=user_message_metadata,
         khoj_message_metadata=khoj_message_metadata,
-        conversation_log=meta_log.get("chat", []),
+        chat_history=chat_history,
     )
     await ConversationAdapters.save_conversation(
         user,
-        {"chat": updated_conversation},
+        updated_conversation,
         client_application=client_application,
         conversation_id=conversation_id,
         user_message=q,
@@ -502,7 +511,7 @@ def gather_raw_query_files(
 def generate_chatml_messages_with_context(
     user_message: str,
     system_message: str = None,
-    conversation_log={},
+    chat_history: list[ChatMessageModel] = [],
     model_name="gpt-4o-mini",
     loaded_model: Optional[Llama] = None,
     max_prompt_size=None,
@@ -529,21 +538,21 @@ def generate_chatml_messages_with_context(
 
     # Extract Chat History for Context
     chatml_messages: List[ChatMessage] = []
-    for chat in conversation_log.get("chat", []):
+    for chat in chat_history:
         message_context = []
         message_attached_files = ""
 
         generated_assets = {}
 
-        chat_message = chat.get("message")
-        role = "user" if chat["by"] == "you" else "assistant"
+        chat_message = chat.message
+        role = "user" if chat.by == "you" else "assistant"
 
         # Legacy code to handle excalidraw diagrams prior to Dec 2024
-        if chat["by"] == "khoj" and "excalidraw" in chat["intent"].get("type", ""):
-            chat_message = chat["intent"].get("inferred-queries")[0]
+        if chat.by == "khoj" and "excalidraw" in chat.intent.type or "":
+            chat_message = (chat.intent.inferred_queries or [])[0]
 
-        if chat.get("queryFiles"):
-            raw_query_files = chat.get("queryFiles")
+        if chat.queryFiles:
+            raw_query_files = chat.queryFiles
             query_files_dict = dict()
             for file in raw_query_files:
                 query_files_dict[file["name"]] = file["content"]
@@ -551,24 +560,24 @@ def generate_chatml_messages_with_context(
             message_attached_files = gather_raw_query_files(query_files_dict)
             chatml_messages.append(ChatMessage(content=message_attached_files, role=role))
 
-        if not is_none_or_empty(chat.get("onlineContext")):
+        if not is_none_or_empty(chat.onlineContext):
             message_context += [
                 {
                     "type": "text",
-                    "text": f"{prompts.online_search_conversation.format(online_results=chat.get('onlineContext'))}",
+                    "text": f"{prompts.online_search_conversation.format(online_results=chat.onlineContext)}",
                 }
             ]
 
-        if not is_none_or_empty(chat.get("codeContext")):
+        if not is_none_or_empty(chat.codeContext):
             message_context += [
                 {
                     "type": "text",
-                    "text": f"{prompts.code_executed_context.format(code_results=chat.get('codeContext'))}",
+                    "text": f"{prompts.code_executed_context.format(code_results=chat.codeContext)}",
                 }
             ]
 
-        if not is_none_or_empty(chat.get("operatorContext")):
-            operator_context = chat.get("operatorContext")
+        if not is_none_or_empty(chat.operatorContext):
+            operator_context = chat.operatorContext
             operator_content = "\n\n".join([f'## Task: {oc["query"]}\n{oc["response"]}\n' for oc in operator_context])
             message_context += [
                 {
@@ -577,13 +586,9 @@ def generate_chatml_messages_with_context(
                 }
             ]
 
-        if not is_none_or_empty(chat.get("context")):
+        if not is_none_or_empty(chat.context):
             references = "\n\n".join(
-                {
-                    f"# File: {item['file']}\n## {item['compiled']}\n"
-                    for item in chat.get("context") or []
-                    if isinstance(item, dict)
-                }
+                {f"# File: {item.file}\n## {item.compiled}\n" for item in chat.context or [] if isinstance(item, dict)}
             )
             message_context += [{"type": "text", "text": f"{prompts.notes_conversation.format(references=references)}"}]
 
@@ -591,14 +596,14 @@ def generate_chatml_messages_with_context(
             reconstructed_context_message = ChatMessage(content=message_context, role="user")
             chatml_messages.insert(0, reconstructed_context_message)
 
-        if not is_none_or_empty(chat.get("images")) and role == "assistant":
+        if not is_none_or_empty(chat.images) and role == "assistant":
             generated_assets["image"] = {
-                "query": chat.get("intent", {}).get("inferred-queries", [user_message])[0],
+                "query": (chat.intent.inferred_queries or [user_message])[0],
             }
 
-        if not is_none_or_empty(chat.get("mermaidjsDiagram")) and role == "assistant":
+        if not is_none_or_empty(chat.mermaidjsDiagram) and role == "assistant":
             generated_assets["diagram"] = {
-                "query": chat.get("intent", {}).get("inferred-queries", [user_message])[0],
+                "query": (chat.intent.inferred_queries or [user_message])[0],
             }
 
         if not is_none_or_empty(generated_assets):
@@ -610,7 +615,7 @@ def generate_chatml_messages_with_context(
             )
 
         message_content = construct_structured_message(
-            chat_message, chat.get("images") if role == "user" else [], model_type, vision_enabled
+            chat_message, chat.images if role == "user" else [], model_type, vision_enabled
         )
 
         reconstructed_message = ChatMessage(content=message_content, role=role)

khoj/processor/image/generate.py

@@ -10,7 +10,12 @@ from google import genai
 from google.genai import types as gtypes
 
 from khoj.database.adapters import ConversationAdapters
-from khoj.database.models import Agent, KhojUser, TextToImageModelConfig
+from khoj.database.models import (
+    Agent,
+    ChatMessageModel,
+    KhojUser,
+    TextToImageModelConfig,
+)
 from khoj.routers.helpers import ChatEvent, generate_better_image_prompt
 from khoj.routers.storage import upload_generated_image_to_bucket
 from khoj.utils import state
@@ -23,7 +28,7 @@ logger = logging.getLogger(__name__)
 async def text_to_image(
     message: str,
     user: KhojUser,
-    conversation_log: dict,
+    chat_history: List[ChatMessageModel],
     location_data: LocationData,
     references: List[Dict[str, Any]],
     online_results: Dict[str, Any],
@@ -46,14 +51,14 @@ async def text_to_image(
         return
 
     text2image_model = text_to_image_config.model_name
-    chat_history = ""
-    for chat in conversation_log.get("chat", [])[-4:]:
-        if chat["by"] == "khoj" and chat["intent"].get("type") in ["remember", "reminder"]:
-            chat_history += f"Q: {chat['intent']['query']}\n"
-            chat_history += f"A: {chat['message']}\n"
-        elif chat["by"] == "khoj" and chat.get("images"):
-            chat_history += f"Q: {chat['intent']['query']}\n"
-            chat_history += f"A: Improved Prompt: {chat['intent']['inferred-queries'][0]}\n"
+    chat_history_str = ""
+    for chat in chat_history[-4:]:
+        if chat.by == "khoj" and chat.intent and chat.intent.type in ["remember", "reminder"]:
+            chat_history_str += f"Q: {chat.intent.query or ''}\n"
+            chat_history_str += f"A: {chat.message}\n"
+        elif chat.by == "khoj" and chat.images:
+            chat_history_str += f"Q: {chat.intent.query}\n"
+            chat_history_str += f"A: Improved Prompt: {chat.intent.inferred_queries[0]}\n"
 
     if send_status_func:
         async for event in send_status_func("**Enhancing the Painting Prompt**"):
@@ -63,7 +68,7 @@ async def text_to_image(
     # Use the user's message, chat history, and other context
     image_prompt = await generate_better_image_prompt(
         message,
-        chat_history,
+        chat_history_str,
         location_data=location_data,
         note_references=references,
         online_results=online_results,

khoj/processor/operator/__init__.py

@@ -5,10 +5,9 @@ import os
 from typing import Callable, List, Optional
 
 from khoj.database.adapters import AgentAdapters, ConversationAdapters
-from khoj.database.models import Agent, ChatModel, KhojUser
+from khoj.database.models import Agent, ChatMessageModel, ChatModel, KhojUser
 from khoj.processor.conversation.utils import (
     OperatorRun,
-    construct_chat_history,
     construct_chat_history_for_operator,
 )
 from khoj.processor.operator.operator_actions import *
@@ -34,7 +33,7 @@ logger = logging.getLogger(__name__)
 async def operate_environment(
     query: str,
     user: KhojUser,
-    conversation_log: dict,
+    conversation_log: List[ChatMessageModel],
     location_data: LocationData,
     previous_trajectory: Optional[OperatorRun] = None,
     environment_type: EnvironmentType = EnvironmentType.COMPUTER,

khoj/processor/operator/operator_agent_binary.py

@@ -4,7 +4,7 @@ from datetime import datetime
 from textwrap import dedent
 from typing import List, Optional
 
-from khoj.database.models import ChatModel
+from khoj.database.models import ChatMessageModel, ChatModel
 from khoj.processor.conversation.utils import (
     AgentMessage,
     OperatorRun,
@@ -119,13 +119,13 @@ class BinaryOperatorAgent(OperatorAgent):
             query_screenshot = self._get_message_images(current_message)
 
         # Construct input for visual reasoner history
-        visual_reasoner_history = {"chat": self._format_message_for_api(self.messages)}
+        visual_reasoner_history = self._format_message_for_api(self.messages)
         try:
             natural_language_action = await send_message_to_model_wrapper(
                 query=query_text,
                 query_images=query_screenshot,
                 system_message=reasoning_system_prompt,
-                conversation_log=visual_reasoner_history,
+                chat_history=visual_reasoner_history,
                 agent_chat_model=self.reasoning_model,
                 tracer=self.tracer,
             )
@@ -238,11 +238,11 @@ class BinaryOperatorAgent(OperatorAgent):
 
     async def summarize(self, env_state: EnvState, summarize_prompt: str = None) -> str:
         summarize_prompt = summarize_prompt or self.summarize_prompt
-        conversation_history = {"chat": self._format_message_for_api(self.messages)}
+        conversation_history = self._format_message_for_api(self.messages)
         try:
             summary = await send_message_to_model_wrapper(
                 query=summarize_prompt,
-                conversation_log=conversation_history,
+                chat_history=conversation_history,
                 agent_chat_model=self.reasoning_model,
                 tracer=self.tracer,
             )
@@ -296,14 +296,14 @@ class BinaryOperatorAgent(OperatorAgent):
             images = [item["image_url"]["url"] for item in message.content if item["type"] == "image_url"]
         return images
 
-    def _format_message_for_api(self, messages: list[AgentMessage]) -> List[dict]:
+    def _format_message_for_api(self, messages: list[AgentMessage]) -> List[ChatMessageModel]:
         """Format operator agent messages into the Khoj conversation history format."""
         formatted_messages = [
-            {
-                "message": self._get_message_text(message),
-                "images": self._get_message_images(message),
-                "by": "you" if message.role in ["user", "environment"] else message.role,
-            }
+            ChatMessageModel(
+                message=self._get_message_text(message),
+                images=self._get_message_images(message),
+                by="you" if message.role in ["user", "environment"] else message.role,
+            )
             for message in messages
         ]
         return formatted_messages

khoj/processor/tools/online_search.py

@@ -10,7 +10,13 @@ from bs4 import BeautifulSoup
 from markdownify import markdownify
 
 from khoj.database.adapters import ConversationAdapters
-from khoj.database.models import Agent, KhojUser, ServerChatSettings, WebScraper
+from khoj.database.models import (
+    Agent,
+    ChatMessageModel,
+    KhojUser,
+    ServerChatSettings,
+    WebScraper,
+)
 from khoj.processor.conversation import prompts
 from khoj.routers.helpers import (
     ChatEvent,
@@ -59,7 +65,7 @@ OLOSTEP_QUERY_PARAMS = {
 
 async def search_online(
     query: str,
-    conversation_history: dict,
+    conversation_history: List[ChatMessageModel],
     location: LocationData,
     user: KhojUser,
     send_status_func: Optional[Callable] = None,
@@ -361,7 +367,7 @@ async def search_with_serper(query: str, location: LocationData) -> Tuple[str, D
 
 async def read_webpages(
     query: str,
-    conversation_history: dict,
+    conversation_history: List[ChatMessageModel],
     location: LocationData,
     user: KhojUser,
     send_status_func: Optional[Callable] = None,

khoj/processor/tools/run_code.py

@@ -20,7 +20,7 @@ from tenacity import (
 )
 
 from khoj.database.adapters import FileObjectAdapters
-from khoj.database.models import Agent, FileObject, KhojUser
+from khoj.database.models import Agent, ChatMessageModel, FileObject, KhojUser
 from khoj.processor.conversation import prompts
 from khoj.processor.conversation.utils import (
     ChatEvent,
@@ -50,7 +50,7 @@ class GeneratedCode(NamedTuple):
 
 async def run_code(
     query: str,
-    conversation_history: dict,
+    conversation_history: List[ChatMessageModel],
     context: str,
     location_data: LocationData,
     user: KhojUser,
@@ -116,7 +116,7 @@ async def run_code(
 
 async def generate_python_code(
     q: str,
-    conversation_history: dict,
+    chat_history: List[ChatMessageModel],
     context: str,
     location_data: LocationData,
     user: KhojUser,
@@ -127,7 +127,7 @@ async def generate_python_code(
 ) -> GeneratedCode:
     location = f"{location_data}" if location_data else "Unknown"
     username = prompts.user_name.format(name=user.get_full_name()) if user.get_full_name() else ""
-    chat_history = construct_chat_history(conversation_history)
+    chat_history_str = construct_chat_history(chat_history)
 
     utc_date = datetime.datetime.now(datetime.timezone.utc).strftime("%Y-%m-%d")
     personality_context = (
@@ -143,7 +143,7 @@ async def generate_python_code(
 
     code_generation_prompt = prompts.python_code_generation_prompt.format(
         query=q,
-        chat_history=chat_history,
+        chat_history=chat_history_str,
         context=context,
         has_network_access=network_access_context,
         current_date=utc_date,

khoj/routers/api.py

@@ -29,7 +29,13 @@ from khoj.database.adapters import (
     get_default_search_model,
     get_user_photo,
 )
-from khoj.database.models import Agent, ChatModel, KhojUser, SpeechToTextModelOptions
+from khoj.database.models import (
+    Agent,
+    ChatMessageModel,
+    ChatModel,
+    KhojUser,
+    SpeechToTextModelOptions,
+)
 from khoj.processor.conversation import prompts
 from khoj.processor.conversation.anthropic.anthropic_chat import (
     extract_questions_anthropic,
@@ -353,7 +359,7 @@ def set_user_name(
 
 async def extract_references_and_questions(
     user: KhojUser,
-    meta_log: dict,
+    chat_history: list[ChatMessageModel],
     q: str,
     n: int,
     d: float,
@@ -432,7 +438,7 @@ async def extract_references_and_questions(
                 defiltered_query,
                 model=chat_model,
                 loaded_model=loaded_model,
-                conversation_log=meta_log,
+                chat_history=chat_history,
                 should_extract_questions=True,
                 location_data=location_data,
                 user=user,
@@ -450,7 +456,7 @@ async def extract_references_and_questions(
                 model=chat_model_name,
                 api_key=api_key,
                 api_base_url=base_url,
-                conversation_log=meta_log,
+                chat_history=chat_history,
                 location_data=location_data,
                 user=user,
                 query_images=query_images,
@@ -469,7 +475,7 @@ async def extract_references_and_questions(
                 model=chat_model_name,
                 api_key=api_key,
                 api_base_url=api_base_url,
-                conversation_log=meta_log,
+                chat_history=chat_history,
                 location_data=location_data,
                 user=user,
                 vision_enabled=vision_enabled,
@@ -487,7 +493,7 @@ async def extract_references_and_questions(
                 model=chat_model_name,
                 api_key=api_key,
                 api_base_url=api_base_url,
-                conversation_log=meta_log,
+                chat_history=chat_history,
                 location_data=location_data,
                 max_tokens=chat_model.max_prompt_size,
                 user=user,
@@ -606,7 +612,7 @@ def post_automation(
         return Response(content="Invalid crontime", status_code=400)
 
     # Infer subject, query to run
-    _, query_to_run, generated_subject = schedule_query(q, conversation_history={}, user=user)
+    _, query_to_run, generated_subject = schedule_query(q, chat_history=[], user=user)
     subject = subject or generated_subject
 
     # Normalize query parameters
@@ -712,7 +718,7 @@ def edit_job(
         return Response(content="Invalid automation", status_code=403)
 
     # Infer subject, query to run
-    _, query_to_run, _ = schedule_query(q, conversation_history={}, user=user)
+    _, query_to_run, _ = schedule_query(q, chat_history=[], user=user)
     subject = subject
 
     # Normalize query parameters