PyPI - chainlit - Versions diffs - 0.7.604rc2__py3-none-any.whl → 1.0.0rc0__py3-none-any.whl - Mend

chainlit 0.7.604rc2py3-none-any.whl → 1.0.0rc0py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of chainlit might be problematic. Click here for more details.

Files changed (40) hide show

chainlit/__init__.py +32 -23
chainlit/auth.py +9 -10
chainlit/cache.py +3 -3
chainlit/cli/__init__.py +12 -2
chainlit/config.py +22 -13
chainlit/context.py +7 -3
chainlit/data/__init__.py +375 -9
chainlit/data/acl.py +6 -5
chainlit/element.py +86 -123
chainlit/emitter.py +117 -50
chainlit/frontend/dist/assets/index-6aee009a.js +697 -0
chainlit/frontend/dist/assets/{react-plotly-16f7de12.js → react-plotly-2f07c02a.js} +1 -1
chainlit/frontend/dist/index.html +1 -1
chainlit/haystack/callbacks.py +45 -43
chainlit/hello.py +1 -1
chainlit/langchain/callbacks.py +135 -120
chainlit/llama_index/callbacks.py +68 -48
chainlit/message.py +179 -207
chainlit/oauth_providers.py +39 -34
chainlit/playground/provider.py +44 -30
chainlit/playground/providers/anthropic.py +4 -4
chainlit/playground/providers/huggingface.py +2 -2
chainlit/playground/providers/langchain.py +8 -10
chainlit/playground/providers/openai.py +19 -13
chainlit/server.py +155 -99
chainlit/session.py +109 -40
chainlit/socket.py +54 -38
chainlit/step.py +393 -0
chainlit/types.py +78 -21
chainlit/user.py +32 -0
chainlit/user_session.py +1 -5
{chainlit-0.7.604rc2.dist-info → chainlit-1.0.0rc0.dist-info}/METADATA +12 -31
chainlit-1.0.0rc0.dist-info/RECORD +60 -0
chainlit/client/base.py +0 -169
chainlit/client/cloud.py +0 -500
chainlit/frontend/dist/assets/index-c58dbd4b.js +0 -871
chainlit/prompt.py +0 -40
chainlit-0.7.604rc2.dist-info/RECORD +0 -61
{chainlit-0.7.604rc2.dist-info → chainlit-1.0.0rc0.dist-info}/WHEEL +0 -0
{chainlit-0.7.604rc2.dist-info → chainlit-1.0.0rc0.dist-info}/entry_points.txt +0 -0

chainlit/frontend/dist/index.html CHANGED Viewed

@@ -20,7 +20,7 @@
     <script>
       const global = globalThis;
     </script>
-    <script type="module" crossorigin src="/assets/index-c58dbd4b.js"></script>
+    <script type="module" crossorigin src="/assets/index-6aee009a.js"></script>
     <link rel="stylesheet" href="/assets/index-8942cb2d.css">
   </head>
   <body>

chainlit/haystack/callbacks.py CHANGED Viewed

@@ -1,12 +1,12 @@
+from datetime import datetime
 from typing import Any, Generic, List, Optional, TypeVar
-from chainlit.config import config
 from chainlit.context import context
+from chainlit.step import Step
+from chainlit.sync import run_sync
 from haystack.agents import Agent, Tool
 from haystack.agents.agent_step import AgentStep
-import chainlit as cl
 T = TypeVar("T")
@@ -31,8 +31,8 @@ class Stack(Generic[T]):
 class HaystackAgentCallbackHandler:
-    stack: Stack[cl.Message]
-    latest_agent_message: Optional[cl.Message]
+    stack: Stack[Step]
+    last_step: Optional[Step]
     def __init__(self, agent: Agent):
         agent.callback_manager.on_agent_start += self.on_agent_start
@@ -44,55 +44,53 @@ class HaystackAgentCallbackHandler:
         agent.tm.callback_manager.on_tool_finish += self.on_tool_finish
         agent.tm.callback_manager.on_tool_error += self.on_tool_error
-    def get_root_message(self):
-        if not context.session.root_message:
-            root_message = cl.Message(author=config.ui.name, content="")
-            cl.run_sync(root_message.send())
-        return context.session.root_message
     def on_agent_start(self, **kwargs: Any) -> None:
         # Prepare agent step message for streaming
         self.agent_name = kwargs.get("name", "Agent")
-        self.stack = Stack[cl.Message]()
-        self.stack.push(self.get_root_message())
+        self.stack = Stack[Step]()
+        root_message = context.session.root_message
+        parent_id = root_message.id if root_message else None
+        run_step = Step(name=self.agent_name, type="run", parent_id=parent_id)
+        run_step.start = datetime.utcnow().isoformat()
+        run_step.input = kwargs
-        agent_message = cl.Message(
-            author=self.agent_name, parent_id=self.stack.peek().id, content=""
-        )
-        self.stack.push(agent_message)
+        run_sync(run_step.send())
+        self.stack.push(run_step)
+    def on_agent_finish(self, agent_step: AgentStep, **kwargs: Any) -> None:
+        run_step = self.stack.pop()
+        run_step.end = datetime.utcnow().isoformat()
+        run_step.output = agent_step.prompt_node_response
+        run_sync(run_step.update())
     # This method is called when a step has finished
     def on_agent_step(self, agent_step: AgentStep, **kwargs: Any) -> None:
         # Send previous agent step message
-        self.latest_agent_message = self.stack.pop()
+        self.last_step = self.stack.pop()
         # If token streaming is disabled
-        if self.latest_agent_message.content == "":
-            self.latest_agent_message.content = agent_step.prompt_node_response
-        cl.run_sync(self.latest_agent_message.send())
+        if self.last_step.output == "":
+            self.last_step.output = agent_step.prompt_node_response
+        self.last_step.end = datetime.utcnow().isoformat()
+        run_sync(self.last_step.update())
         if not agent_step.is_last():
-            # Prepare message for next agent step
-            agent_message = cl.Message(
-                author=self.agent_name, parent_id=self.stack.peek().id, content=""
-            )
-            self.stack.push(agent_message)
-    def on_agent_finish(self, agent_step: AgentStep, **kwargs: Any) -> None:
-        self.latest_agent_message = None
-        self.stack.clear()
+            # Prepare step for next agent step
+            step = Step(name=self.agent_name, parent_id=self.stack.peek().id)
+            self.stack.push(step)
     def on_new_token(self, token, **kwargs: Any) -> None:
         # Stream agent step tokens
-        cl.run_sync(self.stack.peek().stream_token(token))
+        run_sync(self.stack.peek().stream_token(token))
     def on_tool_start(self, tool_input: str, tool: Tool, **kwargs: Any) -> None:
-        # Tool started, create message
-        parent_id = self.latest_agent_message.id if self.latest_agent_message else None
-        tool_message = cl.Message(author=tool.name, parent_id=parent_id, content="")
-        self.stack.push(tool_message)
+        # Tool started, create step
+        parent_id = self.stack.items[0].id if self.stack.items[0] else None
+        tool_step = Step(name=tool.name, type="tool", parent_id=parent_id)
+        tool_step.input = tool_input
+        tool_step.start = datetime.utcnow().isoformat()
+        self.stack.push(tool_step)
     def on_tool_finish(
         self,
@@ -101,12 +99,16 @@ class HaystackAgentCallbackHandler:
         tool_input: Optional[str] = None,
         **kwargs: Any
     ) -> None:
-        # Tool finished, send message with tool_result
-        tool_message = self.stack.pop()
-        tool_message.content = tool_result
-        cl.run_sync(tool_message.send())
+        # Tool finished, send step with tool_result
+        tool_step = self.stack.pop()
+        tool_step.output = tool_result
+        tool_step.end = datetime.utcnow().isoformat()
+        run_sync(tool_step.update())
     def on_tool_error(self, exception: Exception, tool: Tool, **kwargs: Any) -> None:
         # Tool error, send error message
-        cl.run_sync(self.stack.pop().remove())
-        cl.run_sync(cl.ErrorMessage(str(exception), author=tool.name).send())
+        error_step = self.stack.pop()
+        error_step.is_error = True
+        error_step.output = str(exception)
+        error_step.end = datetime.utcnow().isoformat()
+        run_sync(error_step.update())

chainlit/hello.py CHANGED Viewed

@@ -8,5 +8,5 @@ async def main():
     res = await AskUserMessage(content="What is your name?", timeout=30).send()
     if res:
         await Message(
-            content=f"Your name is: {res['content']}.\nChainlit installation is working!\nYou can now start building your own chainlit apps!",
+            content=f"Your name is: {res['output']}.\nChainlit installation is working!\nYou can now start building your own chainlit apps!",
         ).send()

chainlit/langchain/callbacks.py CHANGED Viewed

@@ -1,13 +1,15 @@
+from datetime import datetime
 from typing import Any, Dict, List, Optional, Union
 from uuid import UUID
 from chainlit.context import context_var
 from chainlit.message import Message
 from chainlit.playground.providers.openai import stringify_function_call
-from chainlit.prompt import Prompt, PromptMessage
+from chainlit.step import Step, TrueStepType
+from chainlit_client import ChatGeneration, CompletionGeneration, GenerationMessage
 from langchain.callbacks.tracers.base import BaseTracer
 from langchain.callbacks.tracers.schemas import Run
-from langchain.schema.messages import BaseMessage
+from langchain.schema import BaseMessage
 from langchain.schema.output import ChatGenerationChunk, GenerationChunk
 DEFAULT_ANSWER_PREFIX_TOKENS = ["Final", "Answer", ":"]
@@ -85,15 +87,15 @@ class FinalStreamHelper:
             self.last_tokens_stripped.pop(0)
-class PromptHelper:
-    prompt_sequence: List[Prompt]
+class GenerationHelper:
+    generation_sequence: List[Union[ChatGeneration, CompletionGeneration]]
     def __init__(self) -> None:
-        self.prompt_sequence = []
+        self.generation_sequence = []
     @property
-    def current_prompt(self):
-        return self.prompt_sequence[-1] if self.prompt_sequence else None
+    def current_generation(self):
+        return self.generation_sequence[-1] if self.generation_sequence else None
     def _convert_message_role(self, role: str):
         if "human" in role.lower():
@@ -109,7 +111,7 @@ class PromptHelper:
         self,
         message: Dict,
         template: Optional[str] = None,
-        template_format: Optional[str] = None,
+        template_format: str = "f-string",
     ):
         class_name = message["id"][-1]
         kwargs = message.get("kwargs", {})
@@ -118,7 +120,7 @@ class PromptHelper:
             content = stringify_function_call(function_call)
         else:
             content = kwargs.get("content", "")
-        return PromptMessage(
+        return GenerationMessage(
             name=kwargs.get("name"),
             role=self._convert_message_role(class_name),
             template=template,
@@ -130,7 +132,7 @@ class PromptHelper:
         self,
         message: Union[Dict, BaseMessage],
         template: Optional[str] = None,
-        template_format: Optional[str] = None,
+        template_format: str = "f-string",
     ):
         if isinstance(message, dict):
             return self._convert_message_dict(
@@ -141,7 +143,7 @@ class PromptHelper:
             content = stringify_function_call(function_call)
         else:
             content = message.content
-        return PromptMessage(
+        return GenerationMessage(
             name=getattr(message, "name", None),
             role=self._convert_message_role(message.type),
             template=template,
@@ -165,16 +167,16 @@ class PromptHelper:
             return chain_messages
-    def _build_prompt(self, serialized: Dict, inputs: Dict):
+    def _build_generation(self, serialized: Dict, inputs: Dict):
         messages = self._get_messages(serialized)
         if messages:
             # If prompt is chat, the formatted values will be added in on_chat_model_start
-            self._build_chat_template_prompt(messages, inputs)
+            self._build_chat_template_generation(messages, inputs)
         else:
             # For completion prompt everything is done here
-            self._build_completion_prompt(serialized, inputs)
+            self._build_completion_generation(serialized, inputs)
-    def _build_completion_prompt(self, serialized: Dict, inputs: Dict):
+    def _build_completion_generation(self, serialized: Dict, inputs: Dict):
         if not serialized:
             return
         kwargs = serialized.get("kwargs", {})
@@ -185,15 +187,15 @@ class PromptHelper:
         if not template:
             return
-        self.prompt_sequence.append(
-            Prompt(
+        self.generation_sequence.append(
+            CompletionGeneration(
                 template=template,
                 template_format=template_format,
                 inputs=stringified_inputs,
             )
         )
-    def _build_default_prompt(
+    def _build_default_generation(
         self,
         run: Run,
         generation_type: str,
@@ -203,12 +205,12 @@ class PromptHelper:
     ):
         """Build a prompt once an LLM has been executed if no current prompt exists (without template)"""
         if "chat" in generation_type.lower():
-            return Prompt(
+            return ChatGeneration(
                 provider=provider,
                 settings=llm_settings,
                 completion=completion,
                 messages=[
-                    PromptMessage(
+                    GenerationMessage(
                         formatted=formatted_prompt,
                         role=self._convert_message_role(formatted_prompt.split(":")[0]),
                     )
@@ -216,16 +218,16 @@ class PromptHelper:
                 ],
             )
         else:
-            return Prompt(
+            return CompletionGeneration(
                 provider=provider,
                 settings=llm_settings,
                 completion=completion,
                 formatted=run.inputs.get("prompts", [])[0],
             )
-    def _build_chat_template_prompt(self, lc_messages: List[Dict], inputs: Dict):
-        def build_template_messages() -> List[PromptMessage]:
-            template_messages = []  # type: List[PromptMessage]
+    def _build_chat_template_generation(self, lc_messages: List[Dict], inputs: Dict):
+        def build_template_messages() -> List[GenerationMessage]:
+            template_messages = []  # type: List[GenerationMessage]
             if not lc_messages:
                 return template_messages
@@ -241,18 +243,20 @@ class PromptHelper:
                 if "placeholder" in class_name.lower():
                     variable_name = lc_message.get(
                         "variable_name"
+                    ) or message_kwargs.get(
+                        "variable_name"
                     )  # type: Optional[str]
                     variable = inputs.get(variable_name, [])
                     placeholder_size = len(variable)
                     if placeholder_size:
                         template_messages += [
-                            PromptMessage(placeholder_size=placeholder_size)
+                            GenerationMessage(placeholder_size=placeholder_size)
                         ]
                 else:
                     template_messages += [
-                        PromptMessage(
+                        GenerationMessage(
                             template=template,
-                            template_format=template_format,
                             role=self._convert_message_role(class_name),
                         )
                     ]
@@ -264,18 +268,18 @@ class PromptHelper:
             return
         stringified_inputs = {k: str(v) for (k, v) in inputs.items()}
-        self.prompt_sequence.append(
-            Prompt(messages=template_messages, inputs=stringified_inputs)
+        self.generation_sequence.append(
+            ChatGeneration(messages=template_messages, inputs=stringified_inputs)
         )
-    def _build_chat_formatted_prompt(
+    def _build_chat_formatted_generation(
         self, lc_messages: Union[List[BaseMessage], List[dict]]
     ):
-        if not self.current_prompt:
+        if not self.current_generation:
             return
-        formatted_messages = []  # type: List[PromptMessage]
-        if self.current_prompt.messages:
+        formatted_messages = []  # type: List[GenerationMessage]
+        if self.current_generation.messages:
             # This is needed to compute the correct message index to read
             placeholder_offset = 0
             # The final list of messages
@@ -283,7 +287,7 @@ class PromptHelper:
             # Looping the messages built in build_prompt
             # They only contain the template
             for template_index, template_message in enumerate(
-                self.current_prompt.messages
+                self.current_generation.messages
             ):
                 # If a message has a placeholder size, we need to replace it
                 # With the N following messages, where N is the placeholder size
@@ -319,7 +323,7 @@ class PromptHelper:
                 self._convert_message(lc_message) for lc_message in lc_messages
             ]
-        self.current_prompt.messages = formatted_messages
+        self.current_generation.messages = formatted_messages
     def _build_llm_settings(
         self,
@@ -353,8 +357,8 @@ DEFAULT_TO_IGNORE = ["RunnableSequence", "RunnableParallel", "<lambda>"]
 DEFAULT_TO_KEEP = ["retriever", "llm", "agent", "chain", "tool"]
-class LangchainTracer(BaseTracer, PromptHelper, FinalStreamHelper):
-    llm_stream_message: Dict[str, Message]
+class LangchainTracer(BaseTracer, GenerationHelper, FinalStreamHelper):
+    steps: Dict[str, Step]
     parent_id_map: Dict[str, str]
     ignored_runs: set
@@ -373,7 +377,7 @@ class LangchainTracer(BaseTracer, PromptHelper, FinalStreamHelper):
         **kwargs: Any,
     ) -> None:
         BaseTracer.__init__(self, **kwargs)
-        PromptHelper.__init__(self)
+        GenerationHelper.__init__(self)
         FinalStreamHelper.__init__(
             self,
             answer_prefix_tokens=answer_prefix_tokens,
@@ -381,7 +385,7 @@ class LangchainTracer(BaseTracer, PromptHelper, FinalStreamHelper):
             force_stream_final_answer=force_stream_final_answer,
         )
         self.context = context_var.get()
-        self.llm_stream_message = {}
+        self.steps = {}
         self.parent_id_map = {}
         self.ignored_runs = set()
         self.root_parent_id = (
@@ -417,33 +421,37 @@ class LangchainTracer(BaseTracer, PromptHelper, FinalStreamHelper):
             return self.root_parent_id
         if current_parent_id not in self.parent_id_map:
-            return current_parent_id
+            return None
         while current_parent_id in self.parent_id_map:
-            current_parent_id = self.parent_id_map[current_parent_id]
+            # If the parent id is in the ignored runs, we need to get the parent id of the ignored run
+            if current_parent_id in self.ignored_runs:
+                current_parent_id = self.parent_id_map[current_parent_id]
+            else:
+                return current_parent_id
-        return current_parent_id
+        return self.root_parent_id
     def _should_ignore_run(self, run: Run):
         parent_id = self._get_run_parent_id(run)
+        if parent_id:
+            # Add the parent id of the ignored run in the mapping
+            # so we can re-attach a kept child to the right parent id
+            self.parent_id_map[str(run.id)] = parent_id
         ignore_by_name = run.name in self.to_ignore
         ignore_by_parent = parent_id in self.ignored_runs
         ignore = ignore_by_name or ignore_by_parent
-        if ignore:
-            if parent_id:
-                # Add the parent id of the ignored run in the mapping
-                # so we can re-attach a kept child to the right parent id
-                self.parent_id_map[str(run.id)] = parent_id
-            # Tag the run as ignored
-            self.ignored_runs.add(str(run.id))
         # If the ignore cause is the parent being ignored, check if we should nonetheless keep the child
         if ignore_by_parent and not ignore_by_name and run.run_type in self.to_keep:
-            return False, self._get_non_ignored_parent_id(str(run.id))
+            return False, self._get_non_ignored_parent_id(parent_id)
         else:
+            if ignore:
+                # Tag the run as ignored
+                self.ignored_runs.add(str(run.id))
             return ignore, parent_id
     def _is_annotable(self, run: Run):
@@ -474,12 +482,12 @@ class LangchainTracer(BaseTracer, PromptHelper, FinalStreamHelper):
     ) -> Any:
         """Adding formatted content and new message to the previously built template prompt"""
         lc_messages = messages[0]
-        if not self.current_prompt:
-            self.prompt_sequence.append(
-                Prompt(messages=[self._convert_message(m) for m in lc_messages])
+        if not self.current_generation:
+            self.generation_sequence.append(
+                ChatGeneration(messages=[self._convert_message(m) for m in lc_messages])
             )
         else:
-            self._build_chat_formatted_prompt(lc_messages)
+            self._build_chat_formatted_generation(lc_messages)
         super().on_chat_model_start(
             serialized,
@@ -500,7 +508,7 @@ class LangchainTracer(BaseTracer, PromptHelper, FinalStreamHelper):
         parent_run_id: Optional[UUID] = None,
         **kwargs: Any,
     ) -> Any:
-        msg = self.llm_stream_message.get(str(run_id), None)
+        msg = self.steps.get(str(run_id), None)
         if msg:
             self._run_sync(msg.stream_token(token))
@@ -510,6 +518,7 @@ class LangchainTracer(BaseTracer, PromptHelper, FinalStreamHelper):
             if self.answer_reached:
                 if not self.final_stream:
                     self.final_stream = Message(content="")
+                    self._run_sync(self.final_stream.send())
                 self._run_sync(self.final_stream.stream_token(token))
                 self.has_streamed_final_answer = True
             else:
@@ -530,36 +539,41 @@ class LangchainTracer(BaseTracer, PromptHelper, FinalStreamHelper):
         if run.run_type in ["chain", "prompt"]:
             # Prompt templates are contained in chains or prompts (lcel)
-            self._build_prompt(run.serialized or {}, run.inputs)
+            self._build_generation(run.serialized or {}, run.inputs)
         ignore, parent_id = self._should_ignore_run(run)
         if ignore:
             return
-        disable_human_feedback = not self._is_annotable(run)
+        step_type: TrueStepType = "undefined"
-        if run.run_type == "llm":
-            msg = Message(
-                id=run.id,
-                content="",
-                author=run.name,
-                parent_id=parent_id,
-                disable_human_feedback=disable_human_feedback,
-            )
-            self.llm_stream_message[str(run.id)] = msg
-            self._run_sync(msg.send())
-            return
-        self._run_sync(
-            Message(
-                id=run.id,
-                content="",
-                author=run.name,
-                parent_id=parent_id,
-                disable_human_feedback=disable_human_feedback,
-            ).send()
+        if run.run_type in ["agent", "chain"]:
+            step_type = "run"
+        elif run.run_type == "llm":
+            step_type = "llm"
+        elif run.run_type == "retriever":
+            step_type = "retrieval"
+        elif run.run_type == "tool":
+            step_type = "tool"
+        elif run.run_type == "embedding":
+            step_type = "embedding"
+        disable_feedback = not self._is_annotable(run)
+        step = Step(
+            id=str(run.id),
+            name=run.name,
+            type=step_type,
+            parent_id=parent_id,
+            disable_feedback=disable_feedback,
         )
+        step.start = datetime.utcnow().isoformat()
+        step.input = run.inputs
+        self.steps[str(run.id)] = step
+        self._run_sync(step.send())
     def _on_run_update(self, run: Run) -> None:
         """Process a run upon update."""
@@ -570,74 +584,75 @@ class LangchainTracer(BaseTracer, PromptHelper, FinalStreamHelper):
         if ignore:
             return
-        disable_human_feedback = not self._is_annotable(run)
+        current_step = self.steps.get(str(run.id), None)
         if run.run_type in ["chain"]:
-            if self.prompt_sequence:
-                self.prompt_sequence.pop()
+            if self.generation_sequence:
+                self.generation_sequence.pop()
         if run.run_type == "llm":
             provider, llm_settings = self._build_llm_settings(
                 (run.serialized or {}), (run.extra or {}).get("invocation_params")
             )
             generations = (run.outputs or {}).get("generations", [])
+            llm_output = (run.outputs or {}).get("llm_output")
             completion, language = self._get_completion(generations[0][0])
-            current_prompt = (
-                self.prompt_sequence.pop() if self.prompt_sequence else None
+            current_generation = (
+                self.generation_sequence.pop() if self.generation_sequence else None
             )
-            if current_prompt:
-                current_prompt.provider = provider
-                current_prompt.settings = llm_settings
-                current_prompt.completion = completion
+            if current_generation:
+                current_generation.provider = provider
+                current_generation.settings = llm_settings
+                current_generation.completion = completion
             else:
                 generation_type = generations[0][0].get("type", "")
-                current_prompt = self._build_default_prompt(
+                current_generation = self._build_default_generation(
                     run, generation_type, provider, llm_settings, completion
                 )
-            msg = self.llm_stream_message.get(str(run.id), None)
-            if msg:
-                msg.content = completion
-                msg.language = language
-                msg.prompt = current_prompt
-                self._run_sync(msg.update())
+            if llm_output and current_generation:
+                token_count = llm_output.get("token_usage", {}).get("total_tokens")
+                current_generation.token_count = token_count
+            if current_step:
+                current_step.output = completion
+                current_step.language = language
+                current_step.end = datetime.utcnow().isoformat()
+                current_step.generation = current_generation
+                self._run_sync(current_step.update())
             if self.final_stream and self.has_streamed_final_answer:
                 self.final_stream.content = completion
                 self.final_stream.language = language
-                self.final_stream.prompt = current_prompt
-                self._run_sync(self.final_stream.send())
+                self._run_sync(self.final_stream.update())
             return
         outputs = run.outputs or {}
         output_keys = list(outputs.keys())
+        output = outputs
         if output_keys:
-            content = outputs.get(output_keys[0], "")
-        else:
-            return
+            output = outputs.get(output_keys[0], outputs)
-        if run.run_type in ["agent", "chain"]:
-            pass
-            # # Add the response of the chain/tool
-            # self._run_sync(
-            #     Message(
-            #         content=content,
-            #         author=run.name,
-            #         parent_id=parent_id,
-            #         disable_human_feedback=disable_human_feedback,
-            #     ).send()
-            # )
-        else:
-            self._run_sync(
-                Message(
-                    id=run.id,
-                    content=content,
-                    author=run.name,
-                    parent_id=parent_id,
-                    disable_human_feedback=disable_human_feedback,
-                ).update()
-            )
+        if current_step:
+            current_step.output = output
+            current_step.end = datetime.utcnow().isoformat()
+            self._run_sync(current_step.update())
+    def _on_error(self, error: BaseException, *, run_id: UUID, **kwargs: Any):
+        context_var.set(self.context)
+        if current_step := self.steps.get(str(run_id), None):
+            current_step.is_error = True
+            current_step.output = str(error)
+            current_step.end = datetime.utcnow().isoformat()
+            self._run_sync(current_step.update())
+    on_llm_error = _on_error
+    on_chain_error = _on_error
+    on_tool_error = _on_error
+    on_retriever_error = _on_error
 LangchainCallbackHandler = LangchainTracer

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

Potentially problematic release.

chainlit 0.7.604rc2py3-none-any.whl → 1.0.0rc0py3-none-any.whl