chainlit 1.1.300__py3-none-any.whl → 1.1.300rc0__py3-none-any.whl

chainlit/server.py

@@ -18,7 +18,6 @@ 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,
@@ -34,19 +33,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,
@@ -57,14 +56,12 @@ 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):
@@ -72,9 +69,9 @@ async def lifespan(app: FastAPI):
     port = config.run.port
 
     if host == DEFAULT_HOST:
-        url = f"http://localhost:{port}{ROOT_PATH}"
+        url = f"http://localhost:{port}"
     else:
-        url = f"http://{host}:{port}{ROOT_PATH}"
+        url = f"http://{host}:{port}"
 
     logger.info(f"Your app is available at {url}")
 
@@ -115,7 +112,7 @@ async def lifespan(app: FastAPI):
                                 logger.error(f"Error reloading module: {e}")
 
                         await asyncio.sleep(1)
-                        await sio.emit("reload", {})
+                        await socket.emit("reload", {})
 
                         break
 
@@ -169,36 +166,12 @@ 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)
-
-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(
-    f"{ROOT_PATH}/public",
-    StaticFiles(directory="public", check_dir=False),
-    name="public",
-)
+app = FastAPI(lifespan=lifespan)
 
+app.mount("/public", StaticFiles(directory="public", check_dir=False), name="public")
 app.mount(
-    f"{ROOT_PATH}/assets",
+    "/assets",
     StaticFiles(
         packages=[("chainlit", os.path.join(build_dir, "assets"))],
         follow_symlink=config.project.follow_symlink,
@@ -207,7 +180,7 @@ app.mount(
 )
 
 app.mount(
-    f"{ROOT_PATH}/copilot",
+    "/copilot",
     StaticFiles(
         packages=[("chainlit", copilot_build_dir)],
         follow_symlink=config.project.follow_symlink,
@@ -216,6 +189,22 @@ 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
 # -------------------------------------------------------------------------------
@@ -223,28 +212,11 @@ app.mount(
 if os.environ.get("SLACK_BOT_TOKEN") and os.environ.get("SLACK_SIGNING_SECRET"):
     from chainlit.slack.app import slack_app_handler
 
-    @router.post("/slack/events")
-    async def slack_endpoint(req: Request):
+    @app.post("/slack/events")
+    async def 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
 # -------------------------------------------------------------------------------
@@ -266,17 +238,14 @@ 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:root_path" content="{ROOT_PATH}">"""
+    <meta property="og:url" content="{url}">"""
 
     js = f"""<script>{f"window.theme = {json.dumps(config.ui.theme.to_dict())}; " if config.ui.theme else ""}</script>"""
 
@@ -306,9 +275,6 @@ 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
 
 
@@ -318,7 +284,6 @@ 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
@@ -334,26 +299,15 @@ 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
 
 
-@router.get("/auth/config")
+@app.get("/auth/config")
 async def auth(request: Request):
     return get_configuration()
 
 
-@router.post("/login")
+@app.post("/login")
 async def login(form_data: OAuth2PasswordRequestForm = Depends()):
     if not config.code.password_auth_callback:
         raise HTTPException(
@@ -382,14 +336,14 @@ async def login(form_data: OAuth2PasswordRequestForm = Depends()):
     }
 
 
-@router.post("/logout")
+@app.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}
 
 
-@router.post("/auth/header")
+@app.post("/auth/header")
 async def header_auth(request: Request):
     if not config.code.header_auth_callback:
         raise HTTPException(
@@ -418,7 +372,7 @@ async def header_auth(request: Request):
     }
 
 
-@router.get("/auth/oauth/{provider_id}")
+@app.get("/auth/oauth/{provider_id}")
 async def oauth_login(provider_id: str, request: Request):
     if config.code.oauth_callback is None:
         raise HTTPException(
@@ -459,7 +413,7 @@ async def oauth_login(provider_id: str, request: Request):
     return response
 
 
-@router.get("/auth/oauth/{provider_id}/callback")
+@app.get("/auth/oauth/{provider_id}/callback")
 async def oauth_callback(
     provider_id: str,
     request: Request,
@@ -543,85 +497,7 @@ async def oauth_callback(
     return response
 
 
-# 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")
+@app.get("/project/translations")
 async def project_translations(
     language: str = Query(default="en-US", description="Language code"),
 ):
@@ -637,7 +513,7 @@ async def project_translations(
     )
 
 
-@router.get("/project/settings")
+@app.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"),
@@ -683,7 +559,7 @@ async def project_settings(
     )
 
 
-@router.put("/feedback")
+@app.put("/feedback")
 async def update_feedback(
     request: Request,
     update: UpdateFeedbackRequest,
@@ -702,7 +578,7 @@ async def update_feedback(
     return JSONResponse(content={"success": True, "feedbackId": feedback_id})
 
 
-@router.delete("/feedback")
+@app.delete("/feedback")
 async def delete_feedback(
     request: Request,
     payload: DeleteFeedbackRequest,
@@ -721,7 +597,7 @@ async def delete_feedback(
     return JSONResponse(content={"success": True})
 
 
-@router.post("/project/threads")
+@app.post("/project/threads")
 async def get_user_threads(
     request: Request,
     payload: GetThreadsRequest,
@@ -746,7 +622,7 @@ async def get_user_threads(
     return JSONResponse(content=res.to_dict())
 
 
-@router.get("/project/thread/{thread_id}")
+@app.get("/project/thread/{thread_id}")
 async def get_thread(
     request: Request,
     thread_id: str,
@@ -764,7 +640,7 @@ async def get_thread(
     return JSONResponse(content=res)
 
 
-@router.get("/project/thread/{thread_id}/element/{element_id}")
+@app.get("/project/thread/{thread_id}/element/{element_id}")
 async def get_thread_element(
     request: Request,
     thread_id: str,
@@ -783,7 +659,7 @@ async def get_thread_element(
     return JSONResponse(content=res)
 
 
-@router.delete("/project/thread")
+@app.delete("/project/thread")
 async def delete_thread(
     request: Request,
     payload: DeleteThreadRequest,
@@ -804,7 +680,7 @@ async def delete_thread(
     return JSONResponse(content={"success": True})
 
 
-@router.post("/project/file")
+@app.post("/project/file")
 async def upload_file(
     session_id: str,
     file: UploadFile,
@@ -840,7 +716,7 @@ async def upload_file(
     return JSONResponse(file_response)
 
 
-@router.get("/project/file/{file_id}")
+@app.get("/project/file/{file_id}")
 async def get_file(
     file_id: str,
     session_id: Optional[str] = None,
@@ -862,7 +738,7 @@ async def get_file(
         raise HTTPException(status_code=404, detail="File not found")
 
 
-@router.get("/files/{filename:path}")
+@app.get("/files/{filename:path}")
 async def serve_file(
     filename: str,
     current_user: Annotated[Union[User, PersistedUser], Depends(get_current_user)],
@@ -880,7 +756,7 @@ async def serve_file(
         raise HTTPException(status_code=404, detail="File not found")
 
 
-@router.get("/favicon")
+@app.get("/favicon")
 async def get_favicon():
     custom_favicon_path = os.path.join(APP_ROOT, "public", "favicon.*")
     files = glob.glob(custom_favicon_path)
@@ -895,7 +771,7 @@ async def get_favicon():
     return FileResponse(favicon_path, media_type=media_type)
 
 
-@router.get("/logo")
+@app.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
@@ -917,7 +793,7 @@ async def get_logo(theme: Optional[Theme] = Query(Theme.light)):
     return FileResponse(logo_path, media_type=media_type)
 
 
-@router.get("/avatars/{avatar_id}")
+@app.get("/avatars/{avatar_id}")
 async def get_avatar(avatar_id: str):
     if avatar_id == "default":
         avatar_id = config.ui.name
@@ -936,20 +812,19 @@ async def get_avatar(avatar_id: str):
         return await get_favicon()
 
 
-@router.head("/")
+@app.head("/")
 def status_check():
     return {"message": "Site is operational"}
 
 
-@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
+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)
 
+        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_identifier = slack_user_profile.get("email") or slack_user_id
-    user = User(identifier=USER_PREFIX + user_identifier, metadata=slack_user_profile)
+    user_email = slack_user_profile.get("email")
+    user = User(identifier=USER_PREFIX + user_email, metadata=slack_user_profile)
 
     users_by_slack_id[slack_user_id] = user
 

chainlit/socket.py

@@ -3,7 +3,6 @@ import json
 import time
 import uuid
 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,15 +12,14 @@ 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 sio
+from chainlit.server import socket
 from chainlit.session import WebsocketSession
 from chainlit.telemetry import trace_event
 from chainlit.types import (
     AudioChunk,
     AudioChunkPayload,
     AudioEndPayload,
-    MessagePayload,
-    SystemMessagePayload,
+    UIMessagePayload,
 )
 from chainlit.user_session import user_sessions
 
@@ -54,7 +52,7 @@ async def resume_thread(session: WebsocketSession):
     user_is_author = author == session.user.identifier
 
     if user_is_author:
-        metadata = thread.get("metadata") or {}
+        metadata = thread.get("metadata", {})
         user_sessions[session.id] = metadata.copy()
         if chat_profile := metadata.get("chat_profile"):
             session.chat_profile = chat_profile
@@ -99,8 +97,8 @@ def build_anon_user_identifier(environ):
         return str(uuid.uuid5(uuid.NAMESPACE_DNS, ip))
 
 
-@sio.on("connect")
-async def connect(sid, environ):
+@socket.on("connect")
+async def connect(sid, environ, auth):
     if (
         not config.code.on_chat_start
         and not config.code.on_message
@@ -125,11 +123,11 @@ async def connect(sid, environ):
 
     # Session scoped function to emit to the client
     def emit_fn(event, data):
-        return sio.emit(event, data, to=sid)
+        return socket.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 sio.call(event, data, timeout=timeout, to=sid)
+        return socket.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,10 +138,6 @@ async def connect(sid, environ):
 
     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
-    )
 
     ws_session = WebsocketSession(
         id=session_id,
@@ -154,7 +148,7 @@ async def connect(sid, environ):
         user_env=user_env,
         user=user,
         token=token,
-        chat_profile=chat_profile,
+        chat_profile=environ.get("HTTP_X_CHAINLIT_CHAT_PROFILE"),
         thread_id=environ.get("HTTP_X_CHAINLIT_THREAD_ID"),
         languages=environ.get("HTTP_ACCEPT_LANGUAGE"),
         http_referer=http_referer,
@@ -164,7 +158,7 @@ async def connect(sid, environ):
     return True
 
 
-@sio.on("connection_successful")
+@socket.on("connection_successful")
 async def connection_successful(sid):
     context = init_ws_context(sid)
 
@@ -192,14 +186,14 @@ async def connection_successful(sid):
         context.session.current_task = task
 
 
-@sio.on("clear_session")
+@socket.on("clear_session")
 async def clean_session(sid):
     session = WebsocketSession.get(sid)
     if session:
         session.to_clear = True
 
 
-@sio.on("disconnect")
+@socket.on("disconnect")
 async def disconnect(sid):
     session = WebsocketSession.get(sid)
 
@@ -233,7 +227,7 @@ async def disconnect(sid):
         asyncio.ensure_future(clear_on_timeout(sid))
 
 
-@sio.on("stop")
+@socket.on("stop")
 async def stop(sid):
     if session := WebsocketSession.get(sid):
         trace_event("stop_task")
@@ -248,12 +242,12 @@ async def stop(sid):
             await config.code.on_stop()
 
 
-async def process_message(session: WebsocketSession, payload: MessagePayload):
+async def process_message(session: WebsocketSession, payload: UIMessagePayload):
     """Process a message from the user."""
     try:
         context = init_ws_context(session)
         await context.emitter.task_start()
-        message = await context.emitter.process_message(payload)
+        message = await context.emitter.process_user_message(payload)
 
         if config.code.on_message:
             # Sleep 1ms to make sure any children step starts after the message step start
@@ -270,8 +264,8 @@ async def process_message(session: WebsocketSession, payload: MessagePayload):
         await context.emitter.task_end()
 
 
-@sio.on("client_message")
-async def message(sid, payload: MessagePayload):
+@socket.on("ui_message")
+async def message(sid, payload: UIMessagePayload):
     """Handle a message sent by the User."""
     session = WebsocketSession.require(sid)
 
@@ -279,7 +273,7 @@ async def message(sid, payload: MessagePayload):
     session.current_task = task
 
 
-@sio.on("audio_chunk")
+@socket.on("audio_chunk")
 async def audio_chunk(sid, payload: AudioChunkPayload):
     """Handle an audio chunk sent by the user."""
     session = WebsocketSession.require(sid)
@@ -290,7 +284,7 @@ async def audio_chunk(sid, payload: AudioChunkPayload):
         asyncio.create_task(config.code.on_audio_chunk(AudioChunk(**payload)))
 
 
-@sio.on("audio_end")
+@socket.on("audio_end")
 async def audio_end(sid, payload: AudioEndPayload):
     """Handle the end of the audio stream."""
     session = WebsocketSession.require(sid)
@@ -334,7 +328,7 @@ async def process_action(action: Action):
         logger.warning("No callback found for action %s", action.name)
 
 
-@sio.on("action_call")
+@socket.on("action_call")
 async def call_action(sid, action):
     """Handle an action call from the UI."""
     context = init_ws_context(sid)
@@ -361,7 +355,7 @@ async def call_action(sid, action):
         )
 
 
-@sio.on("chat_settings_change")
+@socket.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)