chainlit 2.0.0__py3-none-any.whl → 2.0.dev0__py3-none-any.whl

chainlit/session.py

@@ -6,7 +6,6 @@ import uuid
 from typing import TYPE_CHECKING, Any, Callable, Deque, Dict, Literal, Optional, Union
 
 import aiofiles
-
 from chainlit.logger import logger
 from chainlit.types import FileReference
 
@@ -18,9 +17,9 @@ ClientType = Literal["webapp", "copilot", "teams", "slack", "discord"]
 
 
 class JSONEncoderIgnoreNonSerializable(json.JSONEncoder):
-    def default(self, o):
+    def default(self, obj):
         try:
-            return super().default(o)
+            return super(JSONEncoderIgnoreNonSerializable, self).default(obj)
         except TypeError:
             return None
 
@@ -113,10 +112,9 @@ class BaseSession:
 
         if path:
             # Copy the file from the given path
-            async with (
-                aiofiles.open(path, "rb") as src,
-                aiofiles.open(file_path, "wb") as dst,
-            ):
+            async with aiofiles.open(path, "rb") as src, aiofiles.open(
+                file_path, "wb"
+            ) as dst:
                 await dst.write(await src.read())
         elif content:
             # Write the provided content to the file

chainlit/slack/__init__.py

@@ -1,6 +1,6 @@
-import importlib.util
-
-if importlib.util.find_spec("slack_bolt") is None:
+try:
+    import slack_bolt
+except ModuleNotFoundError:
     raise ValueError(
         "The slack_bolt package is required to integrate Chainlit with a Slack app. Run `pip install slack_bolt --upgrade`"
     )

chainlit/slack/app.py

@@ -7,9 +7,6 @@ from functools import partial
 from typing import Dict, List, Optional, Union
 
 import httpx
-from slack_bolt.adapter.fastapi.async_handler import AsyncSlackRequestHandler
-from slack_bolt.async_app import AsyncApp
-
 from chainlit.config import config
 from chainlit.context import ChainlitContext, HTTPSession, context, context_var
 from chainlit.data import get_data_layer
@@ -21,6 +18,8 @@ from chainlit.telemetry import trace
 from chainlit.types import Feedback
 from chainlit.user import PersistedUser, User
 from chainlit.user_session import user_session
+from slack_bolt.adapter.fastapi.async_handler import AsyncSlackRequestHandler
+from slack_bolt.async_app import AsyncApp
 
 
 class SlackEmitter(BaseChainlitEmitter):

chainlit/socket.py

@@ -1,28 +1,29 @@
 import asyncio
 import json
 import time
-from typing import Any, Dict, Literal, Optional, Tuple, Union
+import uuid
+from typing import Any, Dict, Literal
 from urllib.parse import unquote
 
-from starlette.requests import cookie_parser
-from typing_extensions import TypeAlias
-
+from chainlit.action import Action
 from chainlit.auth import get_current_user, require_login
 from chainlit.chat_context import chat_context
 from chainlit.config import config
 from chainlit.context import init_ws_context
 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.session import WebsocketSession
 from chainlit.telemetry import trace_event
-from chainlit.types import InputAudioChunk, InputAudioChunkPayload, MessagePayload
-from chainlit.user import PersistedUser, User
+from chainlit.types import (
+    InputAudioChunk,
+    InputAudioChunkPayload,
+    MessagePayload,
+)
 from chainlit.user_session import user_sessions
 
-WSGIEnvironment: TypeAlias = dict[str, Any]
-
 
 def restore_existing_session(sid, session_id, emit_fn, emit_call_fn):
     """Restore a session from the sessionId provided by the client."""
@@ -81,44 +82,45 @@ def load_user_env(user_env):
     return user_env
 
 
-def _get_token_from_cookie(environ: WSGIEnvironment) -> Optional[str]:
-    if cookie_header := environ.get("HTTP_COOKIE", None):
-        cookies = cookie_parser(cookie_header)
-        return cookies.get("access_token", None)
-
-    return None
-
-
-def _get_token(environ: WSGIEnvironment, auth: dict) -> Optional[str]:
-    """Take WSGI environ, return access token."""
-    return _get_token_from_cookie(environ)
-
-
-async def _authenticate_connection(
-    environ,
-    auth,
-) -> Union[Tuple[Union[User, PersistedUser], str], Tuple[None, None]]:
-    if token := _get_token(environ, auth):
-        user = await get_current_user(token=token)
-        if user:
-            return user, token
-
-    return None, None
-
-
-@sio.on("connect")  # pyright: ignore [reportOptionalCall]
-async def connect(sid, environ, auth):
-    user = token = None
-
-    if require_login():
-        try:
-            user, token = await _authenticate_connection(environ, auth)
-        except Exception as e:
-            logger.exception("Exception authenticating connection: %s", e)
+def build_anon_user_identifier(environ):
+    scope = environ.get("asgi.scope", {})
+    client_ip, _ = scope.get("client")
+    ip = environ.get("HTTP_X_FORWARDED_FOR", client_ip)
 
-        if not user:
-            logger.error("Authentication failed in websocket connect.")
-            raise ConnectionRefusedError("authentication failed")
+    try:
+        headers = scope.get("headers", {})
+        user_agent = next(
+            (v.decode("utf-8") for k, v in headers if k.decode("utf-8") == "user-agent")
+        )
+        return str(uuid.uuid5(uuid.NAMESPACE_DNS, user_agent + ip))
+
+    except StopIteration:
+        return str(uuid.uuid5(uuid.NAMESPACE_DNS, ip))
+
+
+@sio.on("connect")
+async def connect(sid, environ):
+    if (
+        not config.code.on_chat_start
+        and not config.code.on_message
+        and not config.code.on_audio_chunk
+    ):
+        logger.warning(
+            "You need to configure at least one of on_chat_start, on_message or on_audio_chunk callback"
+        )
+        return False
+    user = None
+    token = None
+    login_required = require_login()
+    try:
+        # Check if the authentication is required
+        if login_required:
+            authorization_header = environ.get("HTTP_AUTHORIZATION")
+            token = authorization_header.split(" ")[1] if authorization_header else None
+            user = await get_current_user(token=token)
+    except Exception:
+        logger.info("Authentication failed")
+        return False
 
     # Session scoped function to emit to the client
     def emit_fn(event, data):
@@ -128,16 +130,16 @@ async def connect(sid, environ, auth):
     def emit_call_fn(event: Literal["ask", "call_fn"], data, timeout):
         return sio.call(event, data, timeout=timeout, to=sid)
 
-    session_id = auth.get("sessionId")
+    session_id = environ.get("HTTP_X_CHAINLIT_SESSION_ID")
     if restore_existing_session(sid, session_id, emit_fn, emit_call_fn):
         return True
 
-    user_env_string = auth.get("userEnv")
+    user_env_string = environ.get("HTTP_USER_ENV")
     user_env = load_user_env(user_env_string)
 
-    client_type = auth.get("clientType")
+    client_type = environ.get("HTTP_X_CHAINLIT_CLIENT_TYPE")
     http_referer = environ.get("HTTP_REFERER")
-    url_encoded_chat_profile = auth.get("chatProfile")
+    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
     )
@@ -152,7 +154,7 @@ async def connect(sid, environ, auth):
         user=user,
         token=token,
         chat_profile=chat_profile,
-        thread_id=auth.get("threadId"),
+        thread_id=environ.get("HTTP_X_CHAINLIT_THREAD_ID"),
         languages=environ.get("HTTP_ACCEPT_LANGUAGE"),
         http_referer=http_referer,
     )
@@ -161,17 +163,17 @@ async def connect(sid, environ, auth):
     return True
 
 
-@sio.on("connection_successful")  # pyright: ignore [reportOptionalCall]
+@sio.on("connection_successful")
 async def connection_successful(sid):
     context = init_ws_context(sid)
 
+    if context.session.restored:
+        return
+
     await context.emitter.task_end()
     await context.emitter.clear("clear_ask")
     await context.emitter.clear("clear_call_fn")
 
-    if context.session.restored:
-        return
-
     if context.session.thread_id_to_resume and config.code.on_chat_resume:
         thread = await resume_thread(context.session)
         if thread:
@@ -194,14 +196,14 @@ async def connection_successful(sid):
         context.session.current_task = task
 
 
-@sio.on("clear_session")  # pyright: ignore [reportOptionalCall]
+@sio.on("clear_session")
 async def clean_session(sid):
     session = WebsocketSession.get(sid)
     if session:
         session.to_clear = True
 
 
-@sio.on("disconnect")  # pyright: ignore [reportOptionalCall]
+@sio.on("disconnect")
 async def disconnect(sid):
     session = WebsocketSession.get(sid)
 
@@ -235,7 +237,7 @@ async def disconnect(sid):
         asyncio.ensure_future(clear_on_timeout(sid))
 
 
-@sio.on("stop")  # pyright: ignore [reportOptionalCall]
+@sio.on("stop")
 async def stop(sid):
     if session := WebsocketSession.get(sid):
         trace_event("stop_task")
@@ -272,7 +274,7 @@ async def process_message(session: WebsocketSession, payload: MessagePayload):
         await context.emitter.task_end()
 
 
-@sio.on("edit_message")  # pyright: ignore [reportOptionalCall]
+@sio.on("edit_message")
 async def edit_message(sid, payload: MessagePayload):
     """Handle a message sent by the User."""
     session = WebsocketSession.require(sid)
@@ -302,7 +304,7 @@ async def edit_message(sid, payload: MessagePayload):
             await context.emitter.task_end()
 
 
-@sio.on("client_message")  # pyright: ignore [reportOptionalCall]
+@sio.on("client_message")
 async def message(sid, payload: MessagePayload):
     """Handle a message sent by the User."""
     session = WebsocketSession.require(sid)
@@ -311,30 +313,17 @@ async def message(sid, payload: MessagePayload):
     session.current_task = task
 
 
-@sio.on("window_message")  # pyright: ignore [reportOptionalCall]
-async def window_message(sid, data):
-    """Handle a message send by the host window."""
-    session = WebsocketSession.require(sid)
-    init_ws_context(session)
-
-    if config.code.on_window_message:
-        try:
-            await config.code.on_window_message(data)
-        except asyncio.CancelledError:
-            pass
-
-
-@sio.on("audio_start")  # pyright: ignore [reportOptionalCall]
+@sio.on("audio_start")
 async def audio_start(sid):
     """Handle audio init."""
     session = WebsocketSession.require(sid)
 
     context = init_ws_context(session)
     if config.code.on_audio_start:
-        connected = bool(await config.code.on_audio_start())
-        connection_state = "on" if connected else "off"
-        await context.emitter.update_audio_connection(connection_state)
-
+       connected = bool(await config.code.on_audio_start())
+       connection_state = "on" if connected else "off"
+       await context.emitter.update_audio_connection(connection_state)
+        
 
 @sio.on("audio_chunk")
 async def audio_chunk(sid, payload: InputAudioChunkPayload):
@@ -361,7 +350,7 @@ async def audio_end(sid):
 
         if config.code.on_audio_end:
             await config.code.on_audio_end()
-
+            
     except asyncio.CancelledError:
         pass
     except Exception as e:
@@ -373,6 +362,42 @@ async def audio_end(sid):
         await context.emitter.task_end()
 
 
+async def process_action(action: Action):
+    callback = config.code.action_callbacks.get(action.name)
+    if callback:
+        res = await callback(action)
+        return res
+    else:
+        logger.warning("No callback found for action %s", action.name)
+
+
+@sio.on("action_call")
+async def call_action(sid, action):
+    """Handle an action call from the UI."""
+    context = init_ws_context(sid)
+
+    action = Action(**action)
+
+    try:
+        if not context.session.has_first_interaction:
+            context.session.has_first_interaction = True
+            asyncio.create_task(context.emitter.init_thread(action.name))
+        res = await process_action(action)
+        await context.emitter.send_action_response(
+            id=action.id, status=True, response=res if isinstance(res, str) else None
+        )
+
+    except asyncio.CancelledError:
+        await context.emitter.send_action_response(
+            id=action.id, status=False, response="Action interrupted by the user"
+        )
+    except Exception as e:
+        logger.exception(e)
+        await context.emitter.send_action_response(
+            id=action.id, status=False, response="An error occurred"
+        )
+
+
 @sio.on("chat_settings_change")
 async def change_settings(sid, settings: Dict[str, Any]):
     """Handle change settings submit from the UI."""

chainlit/step.py

@@ -7,10 +7,6 @@ from copy import deepcopy
 from functools import wraps
 from typing import Callable, Dict, List, Optional, TypedDict, Union
 
-from literalai import BaseGeneration
-from literalai.helper import utc_now
-from literalai.observability.step import StepType, TrueStepType
-
 from chainlit.config import config
 from chainlit.context import CL_RUN_NAMES, context, local_steps
 from chainlit.data import get_data_layer
@@ -18,6 +14,9 @@ from chainlit.element import Element
 from chainlit.logger import logger
 from chainlit.telemetry import trace_event
 from chainlit.types import FeedbackDict
+from literalai import BaseGeneration
+from literalai.helper import utc_now
+from literalai.observability.step import StepType, TrueStepType
 
 
 def check_add_step_in_cot(step: "Step"):
@@ -62,10 +61,11 @@ class StepDict(TypedDict, total=False):
     generation: Optional[Dict]
     showInput: Optional[Union[bool, str]]
     language: Optional[str]
+    indent: Optional[int]
     feedback: Optional[FeedbackDict]
 
 
-def flatten_args_kwargs(func, args, kwargs):
+def flatten_args_kwargs(func, *args, **kwargs):
     signature = inspect.signature(func)
     bound_arguments = signature.bind(*args, **kwargs)
     bound_arguments.apply_defaults()
@@ -107,8 +107,8 @@ def step(
                 ) as step:
                     try:
                         step.input = flatten_args_kwargs(func, args, kwargs)
-                    except Exception as e:
-                        logger.exception(e)
+                    except:
+                        pass
                     result = await func(*args, **kwargs)
                     try:
                         if result and not step.output:
@@ -134,13 +134,13 @@ def step(
                 ) as step:
                     try:
                         step.input = flatten_args_kwargs(func, args, kwargs)
-                    except Exception as e:
-                        logger.exception(e)
+                    except:
+                        pass
                     result = func(*args, **kwargs)
                     try:
                         if result and not step.output:
                             step.output = result
-                    except Exception as e:
+                    except:
                         step.is_error = True
                         step.output = str(e)
                     return result
@@ -317,7 +317,7 @@ class Step:
             except Exception as e:
                 if self.fail_on_persist_error:
                     raise e
-                logger.error(f"Failed to persist step update: {e!s}")
+                logger.error(f"Failed to persist step update: {str(e)}")
 
         tasks = [el.send(for_id=self.id) for el in self.elements]
         await asyncio.gather(*tasks)
@@ -344,7 +344,7 @@ class Step:
             except Exception as e:
                 if self.fail_on_persist_error:
                     raise e
-                logger.error(f"Failed to persist step deletion: {e!s}")
+                logger.error(f"Failed to persist step deletion: {str(e)}")
 
         await context.emitter.delete_step(step_dict)
 
@@ -371,7 +371,7 @@ class Step:
             except Exception as e:
                 if self.fail_on_persist_error:
                     raise e
-                logger.error(f"Failed to persist step creation: {e!s}")
+                logger.error(f"Failed to persist step creation: {str(e)}")
 
         tasks = [el.send(for_id=self.id) for el in self.elements]
         await asyncio.gather(*tasks)
@@ -434,6 +434,7 @@ class Step:
         if not self.parent_id:
             if parent_step:
                 self.parent_id = parent_step.id
+        context.active_steps.append(self)
         local_steps.set(previous_steps + [self])
         await self.send()
         return self
@@ -445,10 +446,13 @@ class Step:
             self.output = str(exc_val)
             self.is_error = True
 
-        current_steps = local_steps.get()
-        if current_steps and self in current_steps:
-            current_steps.remove(self)
-            local_steps.set(current_steps)
+        if self in context.active_steps:
+            context.active_steps.remove(self)
+
+        local_active_steps = local_steps.get()
+        if local_active_steps and self in local_active_steps:
+            local_active_steps.remove(self)
+            local_steps.set(local_active_steps)
 
         await self.update()
 
@@ -461,6 +465,7 @@ class Step:
         if not self.parent_id:
             if parent_step:
                 self.parent_id = parent_step.id
+        context.active_steps.append(self)
         local_steps.set(previous_steps + [self])
 
         asyncio.create_task(self.send())
@@ -473,9 +478,12 @@ class Step:
             self.output = str(exc_val)
             self.is_error = True
 
-        current_steps = local_steps.get()
-        if current_steps and self in current_steps:
-            current_steps.remove(self)
-            local_steps.set(current_steps)
+        if self in context.active_steps:
+            context.active_steps.remove(self)
+
+        local_active_steps = local_steps.get()
+        if local_active_steps and self in local_active_steps:
+            local_active_steps.remove(self)
+            local_steps.set(local_active_steps)
 
         asyncio.create_task(self.update())

chainlit/sync.py

@@ -10,9 +10,8 @@ import asyncio
 import threading
 
 from asyncer import asyncify
-from syncer import sync
-
 from chainlit.context import context_var
+from syncer import sync
 
 make_async = asyncify
 

chainlit/teams/__init__.py

@@ -1,6 +1,6 @@
-import importlib.util
-
-if importlib.util.find_spec("botbuilder") is None:
+try:
+    import botbuilder
+except ModuleNotFoundError:
     raise ValueError(
         "The botbuilder-core package is required to integrate Chainlit with a Slack app. Run `pip install botbuilder-core --upgrade`"
     )

chainlit/teams/app.py

@@ -28,7 +28,6 @@ from botbuilder.schema import (
     ChannelAccount,
     HeroCard,
 )
-
 from chainlit.config import config
 from chainlit.context import ChainlitContext, HTTPSession, context, context_var
 from chainlit.data import get_data_layer

chainlit/types.py

@@ -79,7 +79,7 @@ T = TypeVar("T", covariant=True)
 class HasFromDict(Protocol[T]):
     @classmethod
     def from_dict(cls, obj_dict: Any) -> T:
-        raise NotImplementedError
+        raise NotImplementedError()
 
 
 @dataclass
@@ -168,13 +168,11 @@ class InputAudioChunk:
     elapsedTime: float
     data: bytes
 
-
 class OutputAudioChunk(TypedDict):
     track: str
     mimeType: str
     data: bytes
 
-
 @dataclass
 class AskFileResponse:
     id: str
@@ -186,16 +184,12 @@ class AskFileResponse:
 
 class AskActionResponse(TypedDict):
     name: str
-    payload: Dict
+    value: str
     label: str
-    tooltip: str
+    description: str
     forId: str
     id: str
-
-
-class UpdateThreadRequest(BaseModel):
-    threadId: str
-    name: str
+    collapsed: bool
 
 
 class DeleteThreadRequest(BaseModel):
@@ -211,16 +205,6 @@ class GetThreadsRequest(BaseModel):
     filter: ThreadFilter
 
 
-class CallActionRequest(BaseModel):
-    action: Dict
-    sessionId: str
-
-
-class ElementRequest(BaseModel):
-    element: Dict
-    sessionId: str
-
-
 class Theme(str, Enum):
     light = "light"
     dark = "dark"

chainlit/user.py

@@ -1,8 +1,7 @@
 from typing import Dict, Literal, Optional, TypedDict
 
 from dataclasses_json import DataClassJsonMixin
-from pydantic import Field
-from pydantic.dataclasses import dataclass
+from pydantic.dataclasses import Field, dataclass
 
 Provider = Literal[
     "credentials",

chainlit/utils.py

@@ -6,13 +6,12 @@ from asyncio import CancelledError
 from typing import Callable
 
 import click
-from fastapi import FastAPI
-from packaging import version
-
 from chainlit.auth import ensure_jwt_secret
 from chainlit.context import context
 from chainlit.logger import logger
 from chainlit.message import ErrorMessage
+from fastapi import FastAPI
+from packaging import version
 
 
 def wrap_user_function(user_function: Callable, with_task=False) -> Callable:

chainlit/version.py

@@ -3,6 +3,5 @@ from importlib import metadata
 try:
     __version__ = metadata.version(__package__)
 except metadata.PackageNotFoundError:
-    # Case where package metadata is not available, default to a 'non-outdated' version.
-    # Ref: config.py::load_settings()
-    __version__ = "0.3.1"
+    # Case where package metadata is not available.
+    __version__ = ""