khoj 1.33.3.dev32__py3-none-any.whl

khoj/routers/notion.py

@@ -0,0 +1,85 @@
+import asyncio
+import base64
+import json
+import logging
+import os
+from concurrent.futures import ThreadPoolExecutor
+
+import requests
+from fastapi import APIRouter, BackgroundTasks, Request, Response
+from starlette.responses import RedirectResponse
+
+from khoj.database.adapters import aget_user_by_uuid
+from khoj.database.models import KhojUser, NotionConfig
+from khoj.routers.helpers import configure_content
+from khoj.utils.state import SearchType
+
+NOTION_OAUTH_CLIENT_ID = os.getenv("NOTION_OAUTH_CLIENT_ID")
+NOTION_OAUTH_CLIENT_SECRET = os.getenv("NOTION_OAUTH_CLIENT_SECRET")
+NOTION_REDIRECT_URI = os.getenv("NOTION_REDIRECT_URI")
+
+notion_router = APIRouter()
+
+executor = ThreadPoolExecutor()
+
+logger = logging.getLogger(__name__)
+
+
+async def run_in_executor(func, *args):
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(executor, func, *args)
+
+
+@notion_router.get("/auth/callback")
+async def notion_auth_callback(request: Request, background_tasks: BackgroundTasks):
+    code = request.query_params.get("code")
+    state = request.query_params.get("state")
+    if not code or not state:
+        return Response("Missing code or state", status_code=400)
+
+    user: KhojUser = await aget_user_by_uuid(state)
+
+    await NotionConfig.objects.filter(user=user).adelete()
+
+    if not user:
+        raise Exception("User not found")
+
+    bearer_token = f"{NOTION_OAUTH_CLIENT_ID}:{NOTION_OAUTH_CLIENT_SECRET}"
+    base64_encoded_token = base64.b64encode(bearer_token.encode()).decode()
+
+    headers = {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        "Authorization": f"Basic {base64_encoded_token}",
+    }
+
+    data = {
+        "grant_type": "authorization_code",
+        "code": code,
+        "redirect_uri": NOTION_REDIRECT_URI,
+    }
+
+    response = requests.post("https://api.notion.com/v1/oauth/token", data=json.dumps(data), headers=headers)
+
+    final_response = response.json()
+
+    logger.info(f"Notion auth callback response: {final_response}")
+
+    access_token = final_response.get("access_token")
+    await NotionConfig.objects.acreate(token=access_token, user=user)
+
+    owner = final_response.get("owner")
+    workspace_id = final_response.get("workspace_id")
+    workspace_name = final_response.get("workspace_name")
+    bot_id = final_response.get("bot_id")
+
+    logger.info(
+        f"Notion integration. Owner: {owner}, Workspace ID: {workspace_id}, Workspace Name: {workspace_name}, Bot ID: {bot_id}"
+    )
+
+    notion_redirect = str(request.app.url_path_for("config_page"))
+
+    # Trigger an async job to configure_content. Let it run without blocking the response.
+    background_tasks.add_task(run_in_executor, configure_content, user, {}, False, SearchType.Notion)
+
+    return RedirectResponse(notion_redirect)

khoj/routers/research.py

@@ -0,0 +1,364 @@
+import logging
+from datetime import datetime
+from typing import Callable, Dict, List, Optional
+
+import yaml
+from fastapi import Request
+
+from khoj.database.models import Agent, KhojUser
+from khoj.processor.conversation import prompts
+from khoj.processor.conversation.utils import (
+    InformationCollectionIteration,
+    construct_chat_history,
+    construct_iteration_history,
+    construct_tool_chat_history,
+    load_complex_json,
+)
+from khoj.processor.tools.online_search import read_webpages, search_online
+from khoj.processor.tools.run_code import run_code
+from khoj.routers.api import extract_references_and_questions
+from khoj.routers.helpers import (
+    ChatEvent,
+    generate_summary_from_files,
+    send_message_to_model_wrapper,
+)
+from khoj.utils.helpers import (
+    ConversationCommand,
+    function_calling_description_for_llm,
+    is_none_or_empty,
+    timer,
+    truncate_code_context,
+)
+from khoj.utils.rawconfig import LocationData
+
+logger = logging.getLogger(__name__)
+
+
+async def apick_next_tool(
+    query: str,
+    conversation_history: dict,
+    user: KhojUser = None,
+    query_images: List[str] = [],
+    location: LocationData = None,
+    user_name: str = None,
+    agent: Agent = None,
+    previous_iterations: List[InformationCollectionIteration] = [],
+    max_iterations: int = 5,
+    send_status_func: Optional[Callable] = None,
+    tracer: dict = {},
+    query_files: str = None,
+):
+    """Given a query, determine which of the available tools the agent should use in order to answer appropriately."""
+
+    # Construct tool options for the agent to choose from
+    tool_options = dict()
+    tool_options_str = ""
+    agent_tools = agent.input_tools if agent else []
+    for tool, description in function_calling_description_for_llm.items():
+        tool_options[tool.value] = description
+        if len(agent_tools) == 0 or tool.value in agent_tools:
+            tool_options_str += f'- "{tool.value}": "{description}"\n'
+
+    # Construct chat history with user and iteration history with researcher agent for context
+    chat_history = construct_chat_history(conversation_history, agent_name=agent.name if agent else "Khoj")
+    previous_iterations_history = construct_iteration_history(previous_iterations, prompts.previous_iteration)
+
+    if query_images:
+        query = f"[placeholder for user attached images]\n{query}"
+
+    today = datetime.today()
+    location_data = f"{location}" if location else "Unknown"
+    personality_context = (
+        prompts.personality_context.format(personality=agent.personality) if agent and agent.personality else ""
+    )
+
+    function_planning_prompt = prompts.plan_function_execution.format(
+        tools=tool_options_str,
+        chat_history=chat_history,
+        personality_context=personality_context,
+        current_date=today.strftime("%Y-%m-%d"),
+        day_of_week=today.strftime("%A"),
+        username=user_name or "Unknown",
+        location=location_data,
+        previous_iterations=previous_iterations_history,
+        max_iterations=max_iterations,
+    )
+
+    try:
+        with timer("Chat actor: Infer information sources to refer", logger):
+            response = await send_message_to_model_wrapper(
+                query=query,
+                context=function_planning_prompt,
+                response_type="json_object",
+                user=user,
+                query_images=query_images,
+                query_files=query_files,
+                tracer=tracer,
+            )
+    except Exception as e:
+        logger.error(f"Failed to infer information sources to refer: {e}", exc_info=True)
+        yield InformationCollectionIteration(
+            tool=None,
+            query=None,
+            warning="Failed to infer information sources to refer. Skipping iteration. Try again.",
+        )
+        return
+
+    try:
+        response = load_complex_json(response)
+        selected_tool = response.get("tool", None)
+        generated_query = response.get("query", None)
+        scratchpad = response.get("scratchpad", None)
+        warning = None
+        logger.info(f"Response for determining relevant tools: {response}")
+
+        # Detect selection of previously used query, tool combination.
+        previous_tool_query_combinations = {(i.tool, i.query) for i in previous_iterations if i.warning is None}
+        if (selected_tool, generated_query) in previous_tool_query_combinations:
+            warning = f"Repeated tool, query combination detected. Skipping iteration. Try something different."
+        # Only send client status updates if we'll execute this iteration
+        elif send_status_func:
+            determined_tool_message = "**Determined Tool**: "
+            determined_tool_message += f"{selected_tool}({generated_query})." if selected_tool else "respond."
+            determined_tool_message += f"\nReason: {scratchpad}" if scratchpad else ""
+            async for event in send_status_func(f"{scratchpad}"):
+                yield {ChatEvent.STATUS: event}
+
+        yield InformationCollectionIteration(
+            tool=selected_tool,
+            query=generated_query,
+            warning=warning,
+        )
+    except Exception as e:
+        logger.error(f"Invalid response for determining relevant tools: {response}. {e}", exc_info=True)
+        yield InformationCollectionIteration(
+            tool=None,
+            query=None,
+            warning=f"Invalid response for determining relevant tools: {response}. Skipping iteration. Fix error: {e}",
+        )
+
+
+async def execute_information_collection(
+    request: Request,
+    user: KhojUser,
+    query: str,
+    conversation_id: str,
+    conversation_history: dict,
+    query_images: List[str],
+    agent: Agent = None,
+    send_status_func: Optional[Callable] = None,
+    user_name: str = None,
+    location: LocationData = None,
+    file_filters: List[str] = [],
+    tracer: dict = {},
+    query_files: str = None,
+):
+    current_iteration = 0
+    MAX_ITERATIONS = 5
+    previous_iterations: List[InformationCollectionIteration] = []
+    while current_iteration < MAX_ITERATIONS:
+        online_results: Dict = dict()
+        code_results: Dict = dict()
+        document_results: List[Dict[str, str]] = []
+        summarize_files: str = ""
+        this_iteration = InformationCollectionIteration(tool=None, query=query)
+
+        async for result in apick_next_tool(
+            query,
+            conversation_history,
+            user,
+            query_images,
+            location,
+            user_name,
+            agent,
+            previous_iterations,
+            MAX_ITERATIONS,
+            send_status_func,
+            tracer=tracer,
+            query_files=query_files,
+        ):
+            if isinstance(result, dict) and ChatEvent.STATUS in result:
+                yield result[ChatEvent.STATUS]
+            elif isinstance(result, InformationCollectionIteration):
+                this_iteration = result
+
+        # Skip running iteration if warning present in iteration
+        if this_iteration.warning:
+            logger.warning(f"Research mode: {this_iteration.warning}.")
+
+        elif this_iteration.tool == ConversationCommand.Notes:
+            this_iteration.context = []
+            document_results = []
+            previous_inferred_queries = {
+                c["query"] for iteration in previous_iterations if iteration.context for c in iteration.context
+            }
+            async for result in extract_references_and_questions(
+                request,
+                construct_tool_chat_history(previous_iterations, ConversationCommand.Notes),
+                this_iteration.query,
+                7,
+                None,
+                conversation_id,
+                [ConversationCommand.Default],
+                location,
+                send_status_func,
+                query_images,
+                previous_inferred_queries=previous_inferred_queries,
+                agent=agent,
+                tracer=tracer,
+                query_files=query_files,
+            ):
+                if isinstance(result, dict) and ChatEvent.STATUS in result:
+                    yield result[ChatEvent.STATUS]
+                elif isinstance(result, tuple):
+                    document_results = result[0]
+                    this_iteration.context += document_results
+
+            if not is_none_or_empty(document_results):
+                try:
+                    distinct_files = {d["file"] for d in document_results}
+                    distinct_headings = set([d["compiled"].split("\n")[0] for d in document_results if "compiled" in d])
+                    # Strip only leading # from headings
+                    headings_str = "\n- " + "\n- ".join(distinct_headings).replace("#", "")
+                    async for result in send_status_func(
+                        f"**Found {len(distinct_headings)} Notes Across {len(distinct_files)} Files**: {headings_str}"
+                    ):
+                        yield result
+                except Exception as e:
+                    this_iteration.warning = f"Error extracting document references: {e}"
+                    logger.error(this_iteration.warning, exc_info=True)
+
+        elif this_iteration.tool == ConversationCommand.Online:
+            previous_subqueries = {
+                subquery
+                for iteration in previous_iterations
+                if iteration.onlineContext
+                for subquery in iteration.onlineContext.keys()
+            }
+            try:
+                async for result in search_online(
+                    this_iteration.query,
+                    construct_tool_chat_history(previous_iterations, ConversationCommand.Online),
+                    location,
+                    user,
+                    send_status_func,
+                    [],
+                    max_webpages_to_read=0,
+                    query_images=query_images,
+                    previous_subqueries=previous_subqueries,
+                    agent=agent,
+                    tracer=tracer,
+                ):
+                    if isinstance(result, dict) and ChatEvent.STATUS in result:
+                        yield result[ChatEvent.STATUS]
+                    elif is_none_or_empty(result):
+                        this_iteration.warning = "Detected previously run online search queries. Skipping iteration. Try something different."
+                    else:
+                        online_results: Dict[str, Dict] = result  # type: ignore
+                        this_iteration.onlineContext = online_results
+            except Exception as e:
+                this_iteration.warning = f"Error searching online: {e}"
+                logger.error(this_iteration.warning, exc_info=True)
+
+        elif this_iteration.tool == ConversationCommand.Webpage:
+            try:
+                async for result in read_webpages(
+                    this_iteration.query,
+                    construct_tool_chat_history(previous_iterations, ConversationCommand.Webpage),
+                    location,
+                    user,
+                    send_status_func,
+                    query_images=query_images,
+                    agent=agent,
+                    tracer=tracer,
+                    query_files=query_files,
+                ):
+                    if isinstance(result, dict) and ChatEvent.STATUS in result:
+                        yield result[ChatEvent.STATUS]
+                    else:
+                        direct_web_pages: Dict[str, Dict] = result  # type: ignore
+
+                        webpages = []
+                        for web_query in direct_web_pages:
+                            if online_results.get(web_query):
+                                online_results[web_query]["webpages"] = direct_web_pages[web_query]["webpages"]
+                            else:
+                                online_results[web_query] = {"webpages": direct_web_pages[web_query]["webpages"]}
+
+                            for webpage in direct_web_pages[web_query]["webpages"]:
+                                webpages.append(webpage["link"])
+                        this_iteration.onlineContext = online_results
+            except Exception as e:
+                this_iteration.warning = f"Error reading webpages: {e}"
+                logger.error(this_iteration.warning, exc_info=True)
+
+        elif this_iteration.tool == ConversationCommand.Code:
+            try:
+                async for result in run_code(
+                    this_iteration.query,
+                    construct_tool_chat_history(previous_iterations, ConversationCommand.Webpage),
+                    "",
+                    location,
+                    user,
+                    send_status_func,
+                    query_images=query_images,
+                    agent=agent,
+                    query_files=query_files,
+                    tracer=tracer,
+                ):
+                    if isinstance(result, dict) and ChatEvent.STATUS in result:
+                        yield result[ChatEvent.STATUS]
+                    else:
+                        code_results: Dict[str, Dict] = result  # type: ignore
+                        this_iteration.codeContext = code_results
+                async for result in send_status_func(f"**Ran code snippets**: {len(this_iteration.codeContext)}"):
+                    yield result
+            except ValueError as e:
+                this_iteration.warning = f"Error running code: {e}"
+                logger.warning(this_iteration.warning, exc_info=True)
+
+        elif this_iteration.tool == ConversationCommand.Summarize:
+            try:
+                async for result in generate_summary_from_files(
+                    this_iteration.query,
+                    user,
+                    file_filters,
+                    construct_tool_chat_history(previous_iterations),
+                    query_images=query_images,
+                    agent=agent,
+                    send_status_func=send_status_func,
+                    query_files=query_files,
+                ):
+                    if isinstance(result, dict) and ChatEvent.STATUS in result:
+                        yield result[ChatEvent.STATUS]
+                    else:
+                        summarize_files = result  # type: ignore
+            except Exception as e:
+                this_iteration.warning = f"Error summarizing files: {e}"
+                logger.error(this_iteration.warning, exc_info=True)
+
+        else:
+            # No valid tools. This is our exit condition.
+            current_iteration = MAX_ITERATIONS
+
+        current_iteration += 1
+
+        if document_results or online_results or code_results or summarize_files or this_iteration.warning:
+            results_data = f"\n<iteration>{current_iteration}\n<tool>{this_iteration.tool}</tool>\n<query>{this_iteration.query}</query>\n<results>"
+            if document_results:
+                results_data += f"\n<document_references>\n{yaml.dump(document_results, allow_unicode=True, sort_keys=False, default_flow_style=False)}\n</document_references>"
+            if online_results:
+                results_data += f"\n<online_results>\n{yaml.dump(online_results, allow_unicode=True, sort_keys=False, default_flow_style=False)}\n</online_results>"
+            if code_results:
+                results_data += f"\n<code_results>\n{yaml.dump(truncate_code_context(code_results), allow_unicode=True, sort_keys=False, default_flow_style=False)}\n</code_results>"
+            if summarize_files:
+                results_data += f"\n<summarized_files>\n{yaml.dump(summarize_files, allow_unicode=True, sort_keys=False, default_flow_style=False)}\n</summarized_files>"
+            if this_iteration.warning:
+                results_data += f"\n<warning>\n{this_iteration.warning}\n</warning>"
+            results_data += "\n</results>\n</iteration>"
+
+            # intermediate_result = await extract_relevant_info(this_iteration.query, results_data, agent)
+            this_iteration.summarizedResult = results_data
+
+        previous_iterations.append(this_iteration)
+        yield this_iteration

khoj/routers/storage.py

@@ -0,0 +1,63 @@
+import logging
+import os
+import uuid
+
+logger = logging.getLogger(__name__)
+
+AWS_ACCESS_KEY = os.getenv("AWS_ACCESS_KEY")
+AWS_SECRET_KEY = os.getenv("AWS_SECRET_KEY")
+# S3 supports serving assets via your domain. Khoj expects this to be used in production. To enable it:
+# 1. Your bucket name for images should be of the form sub.domain.tld. For example, generated.khoj.dev
+# 2. Add CNAME entry to your domain's DNS records pointing to the S3 bucket. For example, CNAME generated.khoj.dev generated-khoj-dev.s3.amazonaws.com
+AWS_UPLOAD_IMAGE_BUCKET_NAME = os.getenv("AWS_IMAGE_UPLOAD_BUCKET")
+
+aws_enabled = AWS_ACCESS_KEY is not None and AWS_SECRET_KEY is not None and AWS_UPLOAD_IMAGE_BUCKET_NAME is not None
+
+if aws_enabled:
+    from boto3 import client
+
+    s3_client = client("s3", aws_access_key_id=AWS_ACCESS_KEY, aws_secret_access_key=AWS_SECRET_KEY)
+
+
+def upload_image(image: bytes, user_id: uuid.UUID):
+    """Upload the image to the S3 bucket"""
+    if not aws_enabled:
+        logger.info("AWS is not enabled. Skipping image upload")
+        return None
+
+    image_key = f"{user_id}/{uuid.uuid4()}.webp"
+    try:
+        s3_client.put_object(Bucket=AWS_UPLOAD_IMAGE_BUCKET_NAME, Key=image_key, Body=image, ACL="public-read")
+        url = f"https://{AWS_UPLOAD_IMAGE_BUCKET_NAME}/{image_key}"
+        return url
+    except Exception as e:
+        logger.error(f"Failed to upload image to S3: {e}")
+        return None
+
+
+AWS_USER_UPLOADED_IMAGES_BUCKET_NAME = os.getenv("AWS_USER_UPLOADED_IMAGES_BUCKET_NAME")
+
+
+def upload_image_to_bucket(image: bytes, user_id: uuid.UUID):
+    """Upload the image to the S3 bucket"""
+    if not aws_enabled:
+        logger.info("AWS is not enabled. Skipping image upload")
+        return None
+
+    image_key = f"{user_id}/{uuid.uuid4()}.webp"
+    if not AWS_USER_UPLOADED_IMAGES_BUCKET_NAME:
+        logger.error("AWS_USER_UPLOADED_IMAGES_BUCKET_NAME is not set")
+        return None
+
+    try:
+        s3_client.put_object(
+            Bucket=AWS_USER_UPLOADED_IMAGES_BUCKET_NAME,
+            Key=image_key,
+            Body=image,
+            ACL="public-read",
+            ContentType="image/webp",
+        )
+        return f"https://{AWS_USER_UPLOADED_IMAGES_BUCKET_NAME}/{image_key}"
+    except Exception as e:
+        logger.error(f"Failed to upload image to S3: {e}")
+        return None

khoj/routers/twilio.py

@@ -0,0 +1,36 @@
+import logging
+import os
+
+from khoj.database.models import KhojUser
+
+logger = logging.getLogger(__name__)
+
+account_sid = os.getenv("TWILIO_ACCOUNT_SID")
+auth_token = os.getenv("TWILIO_AUTH_TOKEN")
+verification_service_sid = os.getenv("TWILIO_VERIFICATION_SID")
+
+twilio_enabled = account_sid is not None and auth_token is not None and verification_service_sid is not None
+if twilio_enabled:
+    from twilio.rest import Client
+
+    client = Client(account_sid, auth_token)
+
+
+def is_twilio_enabled():
+    return twilio_enabled
+
+
+def create_otp(user: KhojUser):
+    """Create a new OTP for the user"""
+    verification = client.verify.v2.services(verification_service_sid).verifications.create(
+        to=str(user.phone_number), channel="whatsapp"
+    )
+    return verification.sid is not None
+
+
+def verify_otp(user: KhojUser, code: str):
+    """Verify the OTP for the user"""
+    verification_check = client.verify.v2.services(verification_service_sid).verification_checks.create(
+        to=str(user.phone_number), code=code
+    )
+    return verification_check.status == "approved"

khoj/routers/web_client.py

@@ -0,0 +1,141 @@
+# System Packages
+import json
+import os
+
+from fastapi import APIRouter, Request
+from fastapi.responses import FileResponse, HTMLResponse, RedirectResponse
+from fastapi.templating import Jinja2Templates
+from starlette.authentication import requires
+
+from khoj.database.adapters import get_user_github_config
+from khoj.routers.helpers import get_next_url, get_user_config
+from khoj.utils import constants
+from khoj.utils.rawconfig import GithubContentConfig, GithubRepoConfig
+
+# Initialize Router
+web_client = APIRouter()
+templates = Jinja2Templates([constants.web_directory, constants.next_js_directory, constants.pypi_static_directory])
+
+
+# Create Routes
+@web_client.get("/", response_class=FileResponse)
+def index(request: Request):
+    return templates.TemplateResponse("index.html", context={"request": request})
+
+
+@web_client.post("/", response_class=FileResponse)
+@requires(["authenticated"], redirect="login_page")
+def index_post(request: Request):
+    return templates.TemplateResponse("index.html", context={"request": request})
+
+
+@web_client.get("/search", response_class=FileResponse)
+@requires(["authenticated"], redirect="login_page")
+def search_page(request: Request):
+    return templates.TemplateResponse(
+        "search/index.html",
+        context={
+            "request": request,
+        },
+    )
+
+
+@web_client.get("/chat", response_class=FileResponse)
+@requires(["authenticated"], redirect="login_page")
+def chat_page(request: Request):
+    return templates.TemplateResponse(
+        "chat/index.html",
+        context={
+            "request": request,
+        },
+    )
+
+
+@web_client.get("/login", response_class=FileResponse)
+def login_page(request: Request):
+    next_url = get_next_url(request)
+    if request.user.is_authenticated:
+        return RedirectResponse(url=next_url)
+    google_client_id = os.environ.get("GOOGLE_CLIENT_ID")
+    redirect_uri = str(request.app.url_path_for("auth_post"))
+    return templates.TemplateResponse(
+        "login.html",
+        context={
+            "request": request,
+            "google_client_id": google_client_id,
+            "redirect_uri": f"{redirect_uri}?next={next_url}",
+        },
+    )
+
+
+@web_client.get("/agents", response_class=HTMLResponse)
+def agents_page(request: Request):
+    return templates.TemplateResponse(
+        "agents/index.html",
+        context={
+            "request": request,
+        },
+    )
+
+
+@web_client.get("/settings", response_class=HTMLResponse)
+@requires(["authenticated"], redirect="login_page")
+def config_page(request: Request):
+    return templates.TemplateResponse("settings/index.html", context={"request": request})
+
+
+@web_client.get("/settings/content/github", response_class=HTMLResponse)
+@requires(["authenticated"], redirect="login_page")
+def github_config_page(request: Request):
+    user = request.user.object
+    user_config = get_user_config(user, request)
+    current_github_config = get_user_github_config(user)
+
+    if current_github_config:
+        raw_repos = current_github_config.githubrepoconfig.all()
+        repos = []
+        for repo in raw_repos:
+            repos.append(
+                GithubRepoConfig(
+                    name=repo.name,
+                    owner=repo.owner,
+                    branch=repo.branch,
+                )
+            )
+        current_config = GithubContentConfig(
+            pat_token=current_github_config.pat_token,
+            repos=repos,
+        )
+        current_config = json.loads(current_config.json())
+    else:
+        current_config = {}  # type: ignore
+
+    user_config["current_config"] = current_config
+    return templates.TemplateResponse("content_source_github_input.html", context=user_config)
+
+
+@web_client.get("/share/chat/{public_conversation_slug}", response_class=HTMLResponse)
+def view_public_conversation(request: Request):
+    return templates.TemplateResponse(
+        "share/chat/index.html",
+        context={
+            "request": request,
+        },
+    )
+
+
+@web_client.get("/automations", response_class=HTMLResponse)
+def automations_config_page(
+    request: Request,
+):
+    return templates.TemplateResponse(
+        "automations/index.html",
+        context={
+            "request": request,
+        },
+    )
+
+
+@web_client.get("/.well-known/assetlinks.json", response_class=FileResponse)
+def assetlinks(request: Request):
+    return FileResponse(constants.assetlinks_file_path)