chainlit 0.7.604rc2__py3-none-any.whl → 1.0.0rc0__py3-none-any.whl

chainlit/oauth_providers.py

@@ -4,7 +4,7 @@ import urllib.parse
 from typing import Dict, List, Optional, Tuple
 
 import httpx
-from chainlit.client.base import AppUser
+from chainlit.user import User
 from fastapi import HTTPException
 
 
@@ -22,7 +22,7 @@ class OAuthProvider:
     async def get_token(self, code: str, url: str) -> str:
         raise NotImplementedError()
 
-    async def get_user_info(self, token: str) -> Tuple[Dict[str, str], AppUser]:
+    async def get_user_info(self, token: str) -> Tuple[Dict[str, str], User]:
         raise NotImplementedError()
 
 
@@ -65,7 +65,7 @@ class GithubOAuthProvider(OAuthProvider):
                 headers={"Authorization": f"token {token}"},
             )
             user_response.raise_for_status()
-            user = user_response.json()
+            github_user = user_response.json()
 
             emails_response = await client.get(
                 "https://api.github.com/user/emails",
@@ -74,14 +74,12 @@ class GithubOAuthProvider(OAuthProvider):
             emails_response.raise_for_status()
             emails = emails_response.json()
 
-            user.update({"emails": emails})
-
-            app_user = AppUser(
-                username=user["login"],
-                image=user["avatar_url"],
-                provider="github",
+            github_user.update({"emails": emails})
+            user = User(
+                identifier=github_user["login"],
+                metadata={"image": github_user["avatar_url"], "provider": "github"},
             )
-            return (user, app_user)
+            return (github_user, user)
 
 
 class GoogleOAuthProvider(OAuthProvider):
@@ -129,12 +127,12 @@ class GoogleOAuthProvider(OAuthProvider):
                 headers={"Authorization": f"Bearer {token}"},
             )
             response.raise_for_status()
-            user = response.json()
-
-            app_user = AppUser(
-                username=user["name"], image=user["picture"], provider="google"
+            google_user = response.json()
+            user = User(
+                identifier=google_user["email"],
+                metadata={"image": google_user["picture"], "provider": "google"},
             )
-            return (user, app_user)
+            return (google_user, user)
 
 
 class AzureADOAuthProvider(OAuthProvider):
@@ -196,7 +194,7 @@ class AzureADOAuthProvider(OAuthProvider):
             )
             response.raise_for_status()
 
-            user = response.json()
+            azure_user = response.json()
 
             try:
                 photo_response = await client.get(
@@ -205,19 +203,18 @@ class AzureADOAuthProvider(OAuthProvider):
                 )
                 photo_data = await photo_response.aread()
                 base64_image = base64.b64encode(photo_data)
-                user[
+                azure_user[
                     "image"
                 ] = f"data:{photo_response.headers['Content-Type']};base64,{base64_image.decode('utf-8')}"
             except Exception as e:
                 # Ignore errors getting the photo
                 pass
 
-            app_user = AppUser(
-                username=user["userPrincipalName"],
-                image=user.get("image", ""),
-                provider="azure-ad",
+            user = User(
+                identifier=azure_user["userPrincipalName"],
+                metadata={"image": azure_user.get("image"), "provider": "azure-ad"},
             )
-            return (user, app_user)
+            return (azure_user, user)
 
 
 class OktaOAuthProvider(OAuthProvider):
@@ -284,10 +281,13 @@ class OktaOAuthProvider(OAuthProvider):
                 headers={"Authorization": f"Bearer {token}"},
             )
             response.raise_for_status()
-            user = response.json()
+            okta_user = response.json()
 
-            app_user = AppUser(username=user.get("email"), image="", provider="okta")
-            return (user, app_user)
+            user = User(
+                identifier=okta_user.get("email"),
+                metadata={"image": "", "provider": "okta"},
+            )
+            return (okta_user, user)
 
 
 class Auth0OAuthProvider(OAuthProvider):
@@ -342,13 +342,15 @@ class Auth0OAuthProvider(OAuthProvider):
                 headers={"Authorization": f"Bearer {token}"},
             )
             response.raise_for_status()
-            user = response.json()
-            app_user = AppUser(
-                username=user.get("email"),
-                image=user.get("picture", ""),
-                provider="auth0",
+            auth0_user = response.json()
+            user = User(
+                identifier=auth0_user.get("email"),
+                metadata={
+                    "image": auth0_user.get("picture", ""),
+                    "provider": "auth0",
+                },
             )
-            return (user, app_user)
+            return (auth0_user, user)
 
 
 class DescopeOAuthProvider(OAuthProvider):
@@ -398,10 +400,13 @@ class DescopeOAuthProvider(OAuthProvider):
                 f"{self.domain}/userinfo", headers={"Authorization": f"Bearer {token}"}
             )
             response.raise_for_status()  # This will raise an exception for 4xx/5xx responses
-            user = response.json()
+            descope_user = response.json()
 
-            app_user = AppUser(username=user.get("email"), image="", provider="descope")
-            return (user, app_user)
+            user = User(
+                identifier=descope_user.get("email"),
+                metadata={"image": "", "provider": "descope"},
+            )
+            return (descope_user, user)
 
 
 providers = [

chainlit/playground/provider.py

@@ -1,10 +1,10 @@
 import os
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Optional, Union
 
 from chainlit.config import config
-from chainlit.prompt import Prompt, PromptMessage
 from chainlit.telemetry import trace_event
-from chainlit.types import CompletionRequest
+from chainlit.types import GenerationRequest
+from chainlit_client import BaseGeneration, ChatGeneration, GenerationMessage
 from fastapi import HTTPException
 from pydantic.dataclasses import dataclass
 
@@ -20,67 +20,81 @@ class BaseProvider:
     is_chat: bool
 
     # Format the message based on the template provided
-    def format_message(self, message: PromptMessage, prompt: Prompt):
+    def format_message(self, message: GenerationMessage, inputs: Optional[Dict]):
         if message.template:
-            message.formatted = self._format_template(message.template, prompt)
+            message.formatted = self._format_template(
+                message.template, inputs, message.template_format
+            )
         return message
 
     # Convert the message to string format
-    def message_to_string(self, message: PromptMessage):
+    def message_to_string(self, message: GenerationMessage):
         return message.formatted
 
     # Concatenate multiple messages with a joiner
-    def concatenate_messages(self, messages: List[PromptMessage], joiner="\n\n"):
+    def concatenate_messages(self, messages: List[GenerationMessage], joiner="\n\n"):
         return joiner.join([self.message_to_string(m) for m in messages])
 
     # Format the template based on the prompt inputs
-    def _format_template(self, template: str, prompt: Prompt):
-        if prompt.template_format == "f-string":
-            return template.format(**(prompt.inputs or {}))
-        raise HTTPException(
-            status_code=422, detail=f"Unsupported format {prompt.template_format}"
-        )
+    def _format_template(
+        self, template: str, inputs: Optional[Dict], format: str = "f-string"
+    ):
+        if format == "f-string":
+            return template.format(**(inputs or {}))
+        raise HTTPException(status_code=422, detail=f"Unsupported format {format}")
 
     # Create a prompt based on the request
-    def create_prompt(self, request: CompletionRequest):
-        prompt = request.prompt
-        if prompt.messages:
-            messages = [self.format_message(m, prompt=prompt) for m in prompt.messages]
+    def create_generation(self, request: GenerationRequest):
+        if request.chatGeneration and request.chatGeneration.messages:
+            messages = [
+                self.format_message(m, request.chatGeneration.inputs)
+                for m in request.chatGeneration.messages
+            ]
         else:
             messages = None
 
         if self.is_chat:
             if messages:
                 return messages
-            elif prompt.template or prompt.formatted:
+            elif request.completionGeneration and (
+                request.completionGeneration.template
+                or request.completionGeneration.formatted
+            ):
                 return [
                     self.format_message(
-                        PromptMessage(
-                            template=prompt.template,
-                            formatted=prompt.formatted,
+                        GenerationMessage(
+                            template=request.completionGeneration.template,
+                            formatted=request.completionGeneration.formatted,
                             role="user",
                         ),
-                        prompt=prompt,
+                        inputs=request.completionGeneration.inputs,
                     )
                 ]
             else:
-                raise HTTPException(status_code=422, detail="Could not create prompt")
+                raise HTTPException(
+                    status_code=422, detail="Could not create generation"
+                )
         else:
-            if prompt.template:
-                return self._format_template(prompt.template, prompt=prompt)
+            if request.completionGeneration:
+                if request.completionGeneration.template:
+                    return self._format_template(
+                        request.completionGeneration.template,
+                        request.completionGeneration.inputs,
+                        request.completionGeneration.template_format,
+                    )
+                elif request.completionGeneration.formatted:
+                    return request.completionGeneration.formatted
             elif messages:
                 return self.concatenate_messages(messages)
-            elif prompt.formatted:
-                return prompt.formatted
             else:
                 raise HTTPException(status_code=422, detail="Could not create prompt")
 
     # Create a completion event
-    async def create_completion(self, request: CompletionRequest):
+    async def create_completion(self, request: GenerationRequest):
         trace_event("completion")
 
     # Get the environment variable based on the request
-    def get_var(self, request: CompletionRequest, var: str) -> Union[str, None]:
+    def get_var(self, request: GenerationRequest, var: str) -> Union[str, None]:
         user_env = config.project.user_env or []
 
         if var in user_env:
@@ -101,7 +115,7 @@ class BaseProvider:
         return True
 
     # Validate the environment variables in the request
-    def validate_env(self, request: CompletionRequest):
+    def validate_env(self, request: GenerationRequest):
         return {k: self.get_var(request, v) for k, v in self.env_vars.items()}
 
     # Check if the required settings are present

chainlit/playground/providers/anthropic.py

@@ -1,12 +1,12 @@
 from chainlit.input_widget import Select, Slider, Tags
 from chainlit.playground.provider import BaseProvider
-from chainlit.prompt import PromptMessage
+from chainlit_client import GenerationMessage
 from fastapi import HTTPException
 from fastapi.responses import StreamingResponse
 
 
 class AnthropicProvider(BaseProvider):
-    def message_to_string(self, message: PromptMessage) -> str:
+    def message_to_string(self, message: GenerationMessage) -> str:
         import anthropic
 
         if message.role == "user":
@@ -29,10 +29,10 @@ class AnthropicProvider(BaseProvider):
 
         env_settings = self.validate_env(request=request)
 
-        llm_settings = request.prompt.settings
+        llm_settings = request.generation.settings
         self.require_settings(llm_settings)
 
-        prompt = self.concatenate_messages(self.create_prompt(request), joiner="")
+        prompt = self.concatenate_messages(self.create_generation(request), joiner="")
 
         if not prompt.endswith(anthropic.AI_PROMPT):
             prompt += anthropic.AI_PROMPT

chainlit/playground/providers/huggingface.py

@@ -18,7 +18,7 @@ class BaseHuggingFaceProvider(BaseProvider):
         from huggingface_hub.inference_api import InferenceApi
 
         env_settings = self.validate_env(request=request)
-        llm_settings = request.prompt.settings
+        llm_settings = request.generation.settings
         self.require_settings(llm_settings)
 
         client = InferenceApi(
@@ -27,7 +27,7 @@ class BaseHuggingFaceProvider(BaseProvider):
             task=self.task,
         )
 
-        prompt = self.create_prompt(request)
+        prompt = self.create_generation(request)
 
         response = await make_async(client)(inputs=prompt, params=llm_settings)
 

chainlit/playground/providers/langchain.py

@@ -1,17 +1,15 @@
 from typing import Union
 
-from fastapi.responses import StreamingResponse
-
 from chainlit.playground.provider import BaseProvider
-from chainlit.prompt import PromptMessage
 from chainlit.sync import make_async
-
-from chainlit import input_widget
+from chainlit_client import GenerationMessage
+from fastapi.responses import StreamingResponse
 
 
 class LangchainGenericProvider(BaseProvider):
     from langchain.chat_models.base import BaseChatModel
     from langchain.llms.base import LLM
+    from langchain.schema import BaseMessage
 
     llm: Union[LLM, BaseChatModel]
 
@@ -31,7 +29,7 @@ class LangchainGenericProvider(BaseProvider):
         )
         self.llm = llm
 
-    def prompt_message_to_langchain_message(self, message: PromptMessage):
+    def prompt_message_to_langchain_message(self, message: GenerationMessage):
         from langchain.schema.messages import (
             AIMessage,
             FunctionMessage,
@@ -46,7 +44,7 @@ class LangchainGenericProvider(BaseProvider):
             return AIMessage(content=content)
         elif message.role == "system":
             return SystemMessage(content=content)
-        elif message.role == "function":
+        elif message.role == "tool":
             return FunctionMessage(
                 content=content, name=message.name if message.name else "function"
             )
@@ -57,15 +55,15 @@ class LangchainGenericProvider(BaseProvider):
         message = super().format_message(message, prompt)
         return self.prompt_message_to_langchain_message(message)
 
-    def message_to_string(self, message: PromptMessage) -> str:
-        return message.to_string()
+    def message_to_string(self, message: BaseMessage) -> str:  # type: ignore[override]
+        return message.content
 
     async def create_completion(self, request):
         from langchain.schema.messages import BaseMessageChunk
 
         await super().create_completion(request)
 
-        messages = self.create_prompt(request)
+        messages = self.create_generation(request)
 
         stream = make_async(self.llm.stream)
 

chainlit/playground/providers/openai.py

@@ -127,11 +127,11 @@ class ChatOpenAIProvider(BaseProvider):
 
         client = AsyncClient(api_key=env_settings["api_key"])
 
-        llm_settings = request.prompt.settings
+        llm_settings = request.generation.settings
 
         self.require_settings(llm_settings)
 
-        messages = self.create_prompt(request)
+        messages = self.create_generation(request)
 
         if "stop" in llm_settings:
             stop = llm_settings["stop"]
@@ -142,8 +142,8 @@ class ChatOpenAIProvider(BaseProvider):
 
             llm_settings["stop"] = stop
 
-        if request.prompt.functions:
-            llm_settings["functions"] = request.prompt.functions
+        if request.generation.functions:
+            llm_settings["functions"] = request.generation.functions
             llm_settings["stream"] = False
         else:
             llm_settings["stream"] = True
@@ -188,11 +188,11 @@ class OpenAIProvider(BaseProvider):
 
         client = AsyncClient(api_key=env_settings["api_key"])
 
-        llm_settings = request.prompt.settings
+        llm_settings = request.generation.settings
 
         self.require_settings(llm_settings)
 
-        prompt = self.create_prompt(request)
+        prompt = self.create_generation(request)
 
         if "stop" in llm_settings:
             stop = llm_settings["stop"]
@@ -240,11 +240,11 @@ class AzureOpenAIProvider(BaseProvider):
             azure_ad_token_provider=self.get_var(request, "AZURE_AD_TOKEN_PROVIDER"),
             azure_deployment=self.get_var(request, "AZURE_DEPLOYMENT"),
         )
-        llm_settings = request.prompt.settings
+        llm_settings = request.generation.settings
 
         self.require_settings(llm_settings)
 
-        prompt = self.create_prompt(request)
+        prompt = self.create_generation(request)
 
         if "stop" in llm_settings:
             stop = llm_settings["stop"]
@@ -294,11 +294,11 @@ class AzureChatOpenAIProvider(BaseProvider):
             azure_deployment=self.get_var(request, "AZURE_DEPLOYMENT"),
         )
 
-        llm_settings = request.prompt.settings
+        llm_settings = request.generation.settings
 
         self.require_settings(llm_settings)
 
-        messages = self.create_prompt(request)
+        messages = self.create_generation(request)
 
         if "stop" in llm_settings:
             stop = llm_settings["stop"]
@@ -311,8 +311,8 @@ class AzureChatOpenAIProvider(BaseProvider):
 
         llm_settings["model"] = env_settings["deployment_name"]
 
-        if request.prompt.functions:
-            llm_settings["functions"] = request.prompt.functions
+        if request.generation.functions:
+            llm_settings["functions"] = request.generation.functions
             llm_settings["stream"] = False
         else:
             llm_settings["stream"] = True
@@ -362,7 +362,13 @@ ChatOpenAI = ChatOpenAIProvider(
         Select(
             id="model",
             label="Model",
-            values=["gpt-3.5-turbo", "gpt-3.5-turbo-16k", "gpt-4", "gpt-4-32k"],
+            values=[
+                "gpt-3.5-turbo",
+                "gpt-3.5-turbo-16k",
+                "gpt-4",
+                "gpt-4-32k",
+                "gpt-4-1106-preview",
+            ],
             initial_value="gpt-3.5-turbo",
         ),
         *openai_common_inputs,