chainlit 1.1.300rc4__py3-none-any.whl → 1.1.301__py3-none-any.whl

chainlit/server.py

@@ -18,6 +18,7 @@ import webbrowser
 from contextlib import asynccontextmanager
 from pathlib import Path
 
+import socketio
 from chainlit.auth import create_jwt, get_configuration, get_current_user
 from chainlit.config import (
     APP_ROOT,
@@ -33,19 +34,19 @@ from chainlit.data import get_data_layer
 from chainlit.data.acl import is_thread_author
 from chainlit.logger import logger
 from chainlit.markdown import get_markdown_str
-from chainlit.telemetry import trace_event
 from chainlit.types import (
     DeleteFeedbackRequest,
     DeleteThreadRequest,
-    GenerationRequest,
     GetThreadsRequest,
     Theme,
     UpdateFeedbackRequest,
 )
 from chainlit.user import PersistedUser, User
 from fastapi import (
+    APIRouter,
     Depends,
     FastAPI,
+    Form,
     HTTPException,
     Query,
     Request,
@@ -56,12 +57,14 @@ from fastapi import (
 from fastapi.responses import FileResponse, HTMLResponse, JSONResponse, RedirectResponse
 from fastapi.security import OAuth2PasswordRequestForm
 from fastapi.staticfiles import StaticFiles
-from fastapi_socketio import SocketManager
 from starlette.datastructures import URL
 from starlette.middleware.cors import CORSMiddleware
 from typing_extensions import Annotated
 from watchfiles import awatch
 
+ROOT_PATH = os.environ.get("CHAINLIT_ROOT_PATH", "")
+IS_SUBMOUNT = os.environ.get("CHAINLIT_SUBMOUNT", "") == "true"
+
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
@@ -69,9 +72,9 @@ async def lifespan(app: FastAPI):
     port = config.run.port
 
     if host == DEFAULT_HOST:
-        url = f"http://localhost:{port}"
+        url = f"http://localhost:{port}{ROOT_PATH}"
     else:
-        url = f"http://{host}:{port}"
+        url = f"http://{host}:{port}{ROOT_PATH}"
 
     logger.info(f"Your app is available at {url}")
 
@@ -112,7 +115,7 @@ async def lifespan(app: FastAPI):
                                 logger.error(f"Error reloading module: {e}")
 
                         await asyncio.sleep(1)
-                        await socket.emit("reload", {})
+                        await sio.emit("reload", {})
 
                         break
 
@@ -166,12 +169,36 @@ def get_build_dir(local_target: str, packaged_target: str):
 build_dir = get_build_dir("frontend", "frontend")
 copilot_build_dir = get_build_dir(os.path.join("libs", "copilot"), "copilot")
 
-
 app = FastAPI(lifespan=lifespan)
 
-app.mount("/public", StaticFiles(directory="public", check_dir=False), name="public")
+sio = socketio.AsyncServer(
+    cors_allowed_origins=[] if IS_SUBMOUNT else "*", async_mode="asgi"
+)
+
+combined_asgi_app = socketio.ASGIApp(
+    sio,
+    app,
+    socketio_path=f"{ROOT_PATH}/ws/socket.io" if ROOT_PATH else "/ws/socket.io",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=config.project.allow_origins,
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+router = APIRouter(prefix=ROOT_PATH)
+
 app.mount(
-    "/assets",
+    f"{ROOT_PATH}/public",
+    StaticFiles(directory="public", check_dir=False),
+    name="public",
+)
+
+app.mount(
+    f"{ROOT_PATH}/assets",
     StaticFiles(
         packages=[("chainlit", os.path.join(build_dir, "assets"))],
         follow_symlink=config.project.follow_symlink,
@@ -180,7 +207,7 @@ app.mount(
 )
 
 app.mount(
-    "/copilot",
+    f"{ROOT_PATH}/copilot",
     StaticFiles(
         packages=[("chainlit", copilot_build_dir)],
         follow_symlink=config.project.follow_symlink,
@@ -189,22 +216,6 @@ app.mount(
 )
 
 
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=config.project.allow_origins,
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-socket = SocketManager(
-    app,
-    cors_allowed_origins=[],
-    async_mode="asgi",
-    socketio_path="/ws/socket.io",
-)
-
-
 # -------------------------------------------------------------------------------
 #                               SLACK HANDLER
 # -------------------------------------------------------------------------------
@@ -212,11 +223,28 @@ socket = SocketManager(
 if os.environ.get("SLACK_BOT_TOKEN") and os.environ.get("SLACK_SIGNING_SECRET"):
     from chainlit.slack.app import slack_app_handler
 
-    @app.post("/slack/events")
-    async def endpoint(req: Request):
+    @router.post("/slack/events")
+    async def slack_endpoint(req: Request):
         return await slack_app_handler.handle(req)
 
 
+# -------------------------------------------------------------------------------
+#                               TEAMS HANDLER
+# -------------------------------------------------------------------------------
+
+if os.environ.get("TEAMS_APP_ID") and os.environ.get("TEAMS_APP_PASSWORD"):
+    from botbuilder.schema import Activity
+    from chainlit.teams.app import adapter, bot
+
+    @router.post("/teams/events")
+    async def teams_endpoint(req: Request):
+        body = await req.json()
+        activity = Activity().deserialize(body)
+        auth_header = req.headers.get("Authorization", "")
+        response = await adapter.process_activity(activity, auth_header, bot.on_turn)
+        return response
+
+
 # -------------------------------------------------------------------------------
 #                               HTTP HANDLERS
 # -------------------------------------------------------------------------------
@@ -238,14 +266,17 @@ def get_html_template():
     )
     url = config.ui.github or default_url
     meta_image_url = config.ui.custom_meta_image_url or default_meta_image_url
+    favicon_path = ROOT_PATH + "/favicon" if ROOT_PATH else "/favicon"
 
     tags = f"""<title>{config.ui.name}</title>
+    <link rel="icon" href="{favicon_path}" />
     <meta name="description" content="{config.ui.description}">
     <meta property="og:type" content="website">
     <meta property="og:title" content="{config.ui.name}">
     <meta property="og:description" content="{config.ui.description}">
     <meta property="og:image" content="{meta_image_url}">
-    <meta property="og:url" content="{url}">"""
+    <meta property="og:url" content="{url}">
+    <meta property="og:root_path" content="{ROOT_PATH}">"""
 
     js = f"""<script>{f"window.theme = {json.dumps(config.ui.theme.to_dict())}; " if config.ui.theme else ""}</script>"""
 
@@ -275,6 +306,9 @@ def get_html_template():
             content = replace_between_tags(
                 content, "<!-- FONT START -->", "<!-- FONT END -->", font
             )
+        if ROOT_PATH:
+            content = content.replace('href="/', f'href="{ROOT_PATH}/')
+            content = content.replace('src="/', f'src="{ROOT_PATH}/')
         return content
 
 
@@ -284,6 +318,7 @@ def get_user_facing_url(url: URL):
     Handles deployment with proxies (like cloud run).
     """
 
+    ROOT_PATH = os.environ.get("CHAINLIT_ROOT_PATH", "")
     chainlit_url = os.environ.get("CHAINLIT_URL")
 
     # No config, we keep the URL as is
@@ -299,15 +334,26 @@ def get_user_facing_url(url: URL):
     if config_url.path.endswith("/"):
         config_url = config_url.replace(path=config_url.path[:-1])
 
+    # Add ROOT_PATH to the final URL if it exists
+    if ROOT_PATH:
+        # Ensure ROOT_PATH starts with a slash
+        if not ROOT_PATH.startswith("/"):
+            ROOT_PATH = "/" + ROOT_PATH
+        # Ensure ROOT_PATH does not end with a slash
+        if ROOT_PATH.endswith("/"):
+            ROOT_PATH = ROOT_PATH[:-1]
+
+        return config_url.__str__() + ROOT_PATH + url.path
+
     return config_url.__str__() + url.path
 
 
-@app.get("/auth/config")
+@router.get("/auth/config")
 async def auth(request: Request):
     return get_configuration()
 
 
-@app.post("/login")
+@router.post("/login")
 async def login(form_data: OAuth2PasswordRequestForm = Depends()):
     if not config.code.password_auth_callback:
         raise HTTPException(
@@ -336,14 +382,14 @@ async def login(form_data: OAuth2PasswordRequestForm = Depends()):
     }
 
 
-@app.post("/logout")
+@router.post("/logout")
 async def logout(request: Request, response: Response):
     if config.code.on_logout:
         return await config.code.on_logout(request, response)
     return {"success": True}
 
 
-@app.post("/auth/header")
+@router.post("/auth/header")
 async def header_auth(request: Request):
     if not config.code.header_auth_callback:
         raise HTTPException(
@@ -372,7 +418,7 @@ async def header_auth(request: Request):
     }
 
 
-@app.get("/auth/oauth/{provider_id}")
+@router.get("/auth/oauth/{provider_id}")
 async def oauth_login(provider_id: str, request: Request):
     if config.code.oauth_callback is None:
         raise HTTPException(
@@ -413,7 +459,7 @@ async def oauth_login(provider_id: str, request: Request):
     return response
 
 
-@app.get("/auth/oauth/{provider_id}/callback")
+@router.get("/auth/oauth/{provider_id}/callback")
 async def oauth_callback(
     provider_id: str,
     request: Request,
@@ -497,7 +543,85 @@ async def oauth_callback(
     return response
 
 
-@app.get("/project/translations")
+# specific route for azure ad hybrid flow
+@router.post("/auth/oauth/azure-ad-hybrid/callback")
+async def oauth_azure_hf_callback(
+    request: Request,
+    error: Optional[str] = None,
+    code: Annotated[Optional[str], Form()] = None,
+    id_token: Annotated[Optional[str], Form()] = None,
+):
+    provider_id = "azure-ad-hybrid"
+    if config.code.oauth_callback is None:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="No oauth_callback defined",
+        )
+
+    provider = get_oauth_provider(provider_id)
+    if not provider:
+        raise HTTPException(
+            status_code=status.HTTP_404_NOT_FOUND,
+            detail=f"Provider {provider_id} not found",
+        )
+
+    if error:
+        params = urllib.parse.urlencode(
+            {
+                "error": error,
+            }
+        )
+        response = RedirectResponse(
+            # FIXME: redirect to the right frontend base url to improve the dev environment
+            url=f"/login?{params}",
+        )
+        return response
+
+    if not code:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail="Missing code",
+        )
+
+    url = get_user_facing_url(request.url)
+    token = await provider.get_token(code, url)
+
+    (raw_user_data, default_user) = await provider.get_user_info(token)
+
+    user = await config.code.oauth_callback(
+        provider_id, token, raw_user_data, default_user, id_token
+    )
+
+    if not user:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Unauthorized",
+        )
+
+    access_token = create_jwt(user)
+
+    if data_layer := get_data_layer():
+        try:
+            await data_layer.create_user(user)
+        except Exception as e:
+            logger.error(f"Error creating user: {e}")
+
+    params = urllib.parse.urlencode(
+        {
+            "access_token": access_token,
+            "token_type": "bearer",
+        }
+    )
+    response = RedirectResponse(
+        # FIXME: redirect to the right frontend base url to improve the dev environment
+        url=f"/login/callback?{params}",
+        status_code=302,
+    )
+    response.delete_cookie("oauth_state")
+    return response
+
+
+@router.get("/project/translations")
 async def project_translations(
     language: str = Query(default="en-US", description="Language code"),
 ):
@@ -513,7 +637,7 @@ async def project_translations(
     )
 
 
-@app.get("/project/settings")
+@router.get("/project/settings")
 async def project_settings(
     current_user: Annotated[Union[User, PersistedUser], Depends(get_current_user)],
     language: str = Query(default="en-US", description="Language code"),
@@ -559,7 +683,7 @@ async def project_settings(
     )
 
 
-@app.put("/feedback")
+@router.put("/feedback")
 async def update_feedback(
     request: Request,
     update: UpdateFeedbackRequest,
@@ -578,7 +702,7 @@ async def update_feedback(
     return JSONResponse(content={"success": True, "feedbackId": feedback_id})
 
 
-@app.delete("/feedback")
+@router.delete("/feedback")
 async def delete_feedback(
     request: Request,
     payload: DeleteFeedbackRequest,
@@ -597,7 +721,7 @@ async def delete_feedback(
     return JSONResponse(content={"success": True})
 
 
-@app.post("/project/threads")
+@router.post("/project/threads")
 async def get_user_threads(
     request: Request,
     payload: GetThreadsRequest,
@@ -622,7 +746,7 @@ async def get_user_threads(
     return JSONResponse(content=res.to_dict())
 
 
-@app.get("/project/thread/{thread_id}")
+@router.get("/project/thread/{thread_id}")
 async def get_thread(
     request: Request,
     thread_id: str,
@@ -640,7 +764,7 @@ async def get_thread(
     return JSONResponse(content=res)
 
 
-@app.get("/project/thread/{thread_id}/element/{element_id}")
+@router.get("/project/thread/{thread_id}/element/{element_id}")
 async def get_thread_element(
     request: Request,
     thread_id: str,
@@ -659,7 +783,7 @@ async def get_thread_element(
     return JSONResponse(content=res)
 
 
-@app.delete("/project/thread")
+@router.delete("/project/thread")
 async def delete_thread(
     request: Request,
     payload: DeleteThreadRequest,
@@ -680,7 +804,7 @@ async def delete_thread(
     return JSONResponse(content={"success": True})
 
 
-@app.post("/project/file")
+@router.post("/project/file")
 async def upload_file(
     session_id: str,
     file: UploadFile,
@@ -716,7 +840,7 @@ async def upload_file(
     return JSONResponse(file_response)
 
 
-@app.get("/project/file/{file_id}")
+@router.get("/project/file/{file_id}")
 async def get_file(
     file_id: str,
     session_id: Optional[str] = None,
@@ -738,7 +862,7 @@ async def get_file(
         raise HTTPException(status_code=404, detail="File not found")
 
 
-@app.get("/files/{filename:path}")
+@router.get("/files/{filename:path}")
 async def serve_file(
     filename: str,
     current_user: Annotated[Union[User, PersistedUser], Depends(get_current_user)],
@@ -756,7 +880,7 @@ async def serve_file(
         raise HTTPException(status_code=404, detail="File not found")
 
 
-@app.get("/favicon")
+@router.get("/favicon")
 async def get_favicon():
     custom_favicon_path = os.path.join(APP_ROOT, "public", "favicon.*")
     files = glob.glob(custom_favicon_path)
@@ -771,7 +895,7 @@ async def get_favicon():
     return FileResponse(favicon_path, media_type=media_type)
 
 
-@app.get("/logo")
+@router.get("/logo")
 async def get_logo(theme: Optional[Theme] = Query(Theme.light)):
     theme_value = theme.value if theme else Theme.light.value
     logo_path = None
@@ -793,7 +917,7 @@ async def get_logo(theme: Optional[Theme] = Query(Theme.light)):
     return FileResponse(logo_path, media_type=media_type)
 
 
-@app.get("/avatars/{avatar_id}")
+@router.get("/avatars/{avatar_id}")
 async def get_avatar(avatar_id: str):
     if avatar_id == "default":
         avatar_id = config.ui.name
@@ -812,19 +936,20 @@ async def get_avatar(avatar_id: str):
         return await get_favicon()
 
 
-@app.head("/")
+@router.head("/")
 def status_check():
     return {"message": "Site is operational"}
 
 
-def register_wildcard_route_handler():
-    @app.get("/{path:path}")
-    async def serve(request: Request, path: str):
-        html_template = get_html_template()
-        """Serve the UI files."""
-        response = HTMLResponse(content=html_template, status_code=200)
+@router.get("/{full_path:path}")
+async def serve():
+    html_template = get_html_template()
+    """Serve the UI files."""
+    response = HTMLResponse(content=html_template, status_code=200)
+
+    return response
 
-        return response
 
+app.include_router(router)
 
 import chainlit.socket  # noqa

chainlit/slack/app.py

@@ -176,8 +176,8 @@ async def get_user(slack_user_id: str):
     slack_user = await slack_app.client.users_info(user=slack_user_id)
     slack_user_profile = slack_user["user"]["profile"]
 
-    user_email = slack_user_profile.get("email")
-    user = User(identifier=USER_PREFIX + user_email, metadata=slack_user_profile)
+    user_identifier = slack_user_profile.get("email") or slack_user_id
+    user = User(identifier=USER_PREFIX + user_identifier, metadata=slack_user_profile)
 
     users_by_slack_id[slack_user_id] = user
 

chainlit/socket.py

@@ -2,8 +2,8 @@ import asyncio
 import json
 import time
 import uuid
-from urllib.parse import unquote
 from typing import Any, Dict, Literal
+from urllib.parse import unquote
 
 from chainlit.action import Action
 from chainlit.auth import get_current_user, require_login
@@ -13,14 +13,15 @@ from chainlit.data import get_data_layer
 from chainlit.element import Element
 from chainlit.logger import logger
 from chainlit.message import ErrorMessage, Message
-from chainlit.server import socket
+from chainlit.server import sio
 from chainlit.session import WebsocketSession
 from chainlit.telemetry import trace_event
 from chainlit.types import (
     AudioChunk,
     AudioChunkPayload,
     AudioEndPayload,
-    UIMessagePayload,
+    MessagePayload,
+    SystemMessagePayload,
 )
 from chainlit.user_session import user_sessions
 
@@ -53,7 +54,7 @@ async def resume_thread(session: WebsocketSession):
     user_is_author = author == session.user.identifier
 
     if user_is_author:
-        metadata = thread.get("metadata", {})
+        metadata = thread.get("metadata") or {}
         user_sessions[session.id] = metadata.copy()
         if chat_profile := metadata.get("chat_profile"):
             session.chat_profile = chat_profile
@@ -98,8 +99,8 @@ def build_anon_user_identifier(environ):
         return str(uuid.uuid5(uuid.NAMESPACE_DNS, ip))
 
 
-@socket.on("connect")
-async def connect(sid, environ, auth):
+@sio.on("connect")
+async def connect(sid, environ):
     if (
         not config.code.on_chat_start
         and not config.code.on_message
@@ -124,11 +125,11 @@ async def connect(sid, environ, auth):
 
     # Session scoped function to emit to the client
     def emit_fn(event, data):
-        return socket.emit(event, data, to=sid)
+        return sio.emit(event, data, to=sid)
 
     # Session scoped function to emit to the client and wait for a response
     def emit_call_fn(event: Literal["ask", "call_fn"], data, timeout):
-        return socket.call(event, data, timeout=timeout, to=sid)
+        return sio.call(event, data, timeout=timeout, to=sid)
 
     session_id = environ.get("HTTP_X_CHAINLIT_SESSION_ID")
     if restore_existing_session(sid, session_id, emit_fn, emit_call_fn):
@@ -140,7 +141,9 @@ async def connect(sid, environ, auth):
     client_type = environ.get("HTTP_X_CHAINLIT_CLIENT_TYPE")
     http_referer = environ.get("HTTP_REFERER")
     url_encoded_chat_profile = environ.get("HTTP_X_CHAINLIT_CHAT_PROFILE")
-    chat_profile = unquote(url_encoded_chat_profile) if url_encoded_chat_profile else None
+    chat_profile = (
+        unquote(url_encoded_chat_profile) if url_encoded_chat_profile else None
+    )
 
     ws_session = WebsocketSession(
         id=session_id,
@@ -161,7 +164,7 @@ async def connect(sid, environ, auth):
     return True
 
 
-@socket.on("connection_successful")
+@sio.on("connection_successful")
 async def connection_successful(sid):
     context = init_ws_context(sid)
 
@@ -189,14 +192,14 @@ async def connection_successful(sid):
         context.session.current_task = task
 
 
-@socket.on("clear_session")
+@sio.on("clear_session")
 async def clean_session(sid):
     session = WebsocketSession.get(sid)
     if session:
         session.to_clear = True
 
 
-@socket.on("disconnect")
+@sio.on("disconnect")
 async def disconnect(sid):
     session = WebsocketSession.get(sid)
 
@@ -230,7 +233,7 @@ async def disconnect(sid):
         asyncio.ensure_future(clear_on_timeout(sid))
 
 
-@socket.on("stop")
+@sio.on("stop")
 async def stop(sid):
     if session := WebsocketSession.get(sid):
         trace_event("stop_task")
@@ -245,12 +248,12 @@ async def stop(sid):
             await config.code.on_stop()
 
 
-async def process_message(session: WebsocketSession, payload: UIMessagePayload):
+async def process_message(session: WebsocketSession, payload: MessagePayload):
     """Process a message from the user."""
     try:
         context = init_ws_context(session)
         await context.emitter.task_start()
-        message = await context.emitter.process_user_message(payload)
+        message = await context.emitter.process_message(payload)
 
         if config.code.on_message:
             # Sleep 1ms to make sure any children step starts after the message step start
@@ -267,8 +270,8 @@ async def process_message(session: WebsocketSession, payload: UIMessagePayload):
         await context.emitter.task_end()
 
 
-@socket.on("ui_message")
-async def message(sid, payload: UIMessagePayload):
+@sio.on("client_message")
+async def message(sid, payload: MessagePayload):
     """Handle a message sent by the User."""
     session = WebsocketSession.require(sid)
 
@@ -276,7 +279,7 @@ async def message(sid, payload: UIMessagePayload):
     session.current_task = task
 
 
-@socket.on("audio_chunk")
+@sio.on("audio_chunk")
 async def audio_chunk(sid, payload: AudioChunkPayload):
     """Handle an audio chunk sent by the user."""
     session = WebsocketSession.require(sid)
@@ -287,7 +290,7 @@ async def audio_chunk(sid, payload: AudioChunkPayload):
         asyncio.create_task(config.code.on_audio_chunk(AudioChunk(**payload)))
 
 
-@socket.on("audio_end")
+@sio.on("audio_end")
 async def audio_end(sid, payload: AudioEndPayload):
     """Handle the end of the audio stream."""
     session = WebsocketSession.require(sid)
@@ -331,7 +334,7 @@ async def process_action(action: Action):
         logger.warning("No callback found for action %s", action.name)
 
 
-@socket.on("action_call")
+@sio.on("action_call")
 async def call_action(sid, action):
     """Handle an action call from the UI."""
     context = init_ws_context(sid)
@@ -358,7 +361,7 @@ async def call_action(sid, action):
         )
 
 
-@socket.on("chat_settings_change")
+@sio.on("chat_settings_change")
 async def change_settings(sid, settings: Dict[str, Any]):
     """Handle change settings submit from the UI."""
     context = init_ws_context(sid)