chatlas 0.6.1__py3-none-any.whl → 0.7.1__py3-none-any.whl

chatlas/_chat.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import inspect
 import os
 import sys
+import traceback
+import warnings
 from pathlib import Path
 from threading import Thread
 from typing import (
@@ -31,7 +33,7 @@ from ._content import (
     ContentToolResult,
 )
 from ._display import (
-    EchoOptions,
+    EchoDisplayOptions,
     IPyMarkdownDisplay,
     LiveMarkdownDisplay,
     MarkdownDisplay,
@@ -57,6 +59,8 @@ method of a [](`~chatlas.Chat`) instance.
 
 CompletionT = TypeVar("CompletionT")
 
+EchoOptions = Literal["output", "all", "none", "text"]
+
 
 class Chat(Generic[SubmitInputArgsT, CompletionT]):
     """
@@ -91,7 +95,8 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         self.provider = provider
         self._turns: list[Turn] = list(turns or [])
         self._tools: dict[str, Tool] = {}
-        self._echo_options: EchoOptions = {
+        self._current_display: Optional[MarkdownDisplay] = None
+        self._echo_options: EchoDisplayOptions = {
             "rich_markdown": {},
             "rich_console": {},
             "css_styles": {},
@@ -390,7 +395,8 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         port: int = 0,
         launch_browser: bool = True,
         bg_thread: Optional[bool] = None,
-        echo: Optional[Literal["text", "all", "none"]] = None,
+        echo: Optional[EchoOptions] = None,
+        content: Literal["text", "all"] = "all",
         kwargs: Optional[SubmitInputArgsT] = None,
     ):
         """
@@ -411,6 +417,8 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             Whether to echo text content, all content (i.e., tool calls), or no
             content. Defaults to `"none"` when `stream=True` and `"text"` when
             `stream=False`.
+        content
+            Whether to display text content or all content (i.e., tool calls).
         kwargs
             Additional keyword arguments to pass to the method used for requesting
             the response.
@@ -439,16 +447,14 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             )
 
             @chat.on_user_submit
-            async def _():
-                user_input = chat.user_input()
-                if user_input is None:
-                    return
+            async def _(user_input: str):
                 if stream:
                     await chat.append_message_stream(
                         await self.stream_async(
                             user_input,
                             kwargs=kwargs,
                             echo=echo or "none",
+                            content=content,
                         )
                     )
                 else:
@@ -457,6 +463,7 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
                             self.chat(
                                 user_input,
                                 kwargs=kwargs,
+                                stream=False,
                                 echo=echo or "text",
                             )
                         )
@@ -485,7 +492,7 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
     def console(
         self,
         *,
-        echo: Literal["text", "all", "none"] = "text",
+        echo: EchoOptions = "output",
         stream: bool = True,
         kwargs: Optional[SubmitInputArgsT] = None,
     ):
@@ -523,7 +530,7 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
     def chat(
         self,
         *args: Content | str,
-        echo: Literal["text", "all", "none"] = "text",
+        echo: EchoOptions = "output",
         stream: bool = True,
         kwargs: Optional[SubmitInputArgsT] = None,
     ) -> ChatResponse:
@@ -558,7 +565,7 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             self._chat_impl(
                 turn,
                 echo=echo,
-                display=display,
+                content="text",
                 stream=stream,
                 kwargs=kwargs,
             )
@@ -573,7 +580,7 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
     async def chat_async(
         self,
         *args: Content | str,
-        echo: Literal["text", "all", "none"] = "text",
+        echo: EchoOptions = "output",
         stream: bool = True,
         kwargs: Optional[SubmitInputArgsT] = None,
     ) -> ChatResponseAsync:
@@ -608,7 +615,7 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             self._chat_impl_async(
                 turn,
                 echo=echo,
-                display=display,
+                content="text",
                 stream=stream,
                 kwargs=kwargs,
             ),
@@ -620,12 +627,44 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
 
         return response
 
+    @overload
+    def stream(
+        self,
+        *args: Content | str,
+    ) -> Generator[str, None, None]: ...
+
+    @overload
+    def stream(
+        self,
+        *args: Content | str,
+        echo: EchoOptions,
+    ) -> Generator[str, None, None]: ...
+
+    @overload
+    def stream(
+        self,
+        *args: Content | str,
+        echo: EchoOptions,
+        content: Literal["text"],
+        kwargs: Optional[SubmitInputArgsT],
+    ) -> Generator[str, None, None]: ...
+
+    @overload
     def stream(
         self,
         *args: Content | str,
-        echo: Literal["text", "all", "none"] = "none",
+        echo: EchoOptions,
+        content: Literal["all"],
+        kwargs: Optional[SubmitInputArgsT],
+    ) -> Generator[str | ContentToolRequest | ContentToolResult, None, None]: ...
+
+    def stream(
+        self,
+        *args: Content | str,
+        echo: EchoOptions = "none",
+        content: Literal["text", "all"] = "text",
         kwargs: Optional[SubmitInputArgsT] = None,
-    ) -> ChatResponse:
+    ) -> Generator[str | ContentToolRequest | ContentToolResult, None, None]:
         """
         Generate a response from the chat in a streaming fashion.
 
@@ -636,6 +675,8 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         echo
             Whether to echo text content, all content (i.e., tool calls), or no
             content.
+        content
+            Whether to yield just text content, or all content (i.e., tool calls).
         kwargs
             Additional keyword arguments to pass to the method used for requesting
             the response.
@@ -653,24 +694,58 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         generator = self._chat_impl(
             turn,
             stream=True,
-            display=display,
             echo=echo,
+            content=content,
             kwargs=kwargs,
         )
 
-        def wrapper() -> Generator[str, None, None]:
+        def wrapper() -> Generator[
+            str | ContentToolRequest | ContentToolResult, None, None
+        ]:
             with display:
                 for chunk in generator:
                     yield chunk
 
-        return ChatResponse(wrapper())
+        return wrapper()
+
+    @overload
+    async def stream_async(
+        self,
+        *args: Content | str,
+    ) -> AsyncGenerator[str, None]: ...
+
+    @overload
+    async def stream_async(
+        self,
+        *args: Content | str,
+        echo: EchoOptions,
+    ) -> AsyncGenerator[str, None]: ...
 
+    @overload
     async def stream_async(
         self,
         *args: Content | str,
-        echo: Literal["text", "all", "none"] = "none",
+        echo: EchoOptions,
+        content: Literal["text"],
+        kwargs: Optional[SubmitInputArgsT],
+    ) -> AsyncGenerator[str, None]: ...
+
+    @overload
+    async def stream_async(
+        self,
+        *args: Content | str,
+        echo: EchoOptions,
+        content: Literal["all"],
+        kwargs: Optional[SubmitInputArgsT],
+    ) -> AsyncGenerator[str | ContentToolRequest | ContentToolResult, None]: ...
+
+    async def stream_async(
+        self,
+        *args: Content | str,
+        echo: EchoOptions = "none",
+        content: Literal["text", "all"] = "text",
         kwargs: Optional[SubmitInputArgsT] = None,
-    ) -> ChatResponseAsync:
+    ) -> AsyncGenerator[str | ContentToolRequest | ContentToolResult, None]:
         """
         Generate a response from the chat in a streaming fashion asynchronously.
 
@@ -681,6 +756,8 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         echo
             Whether to echo text content, all content (i.e., tool calls), or no
             content.
+        content
+            Whether to yield just text content, or all content (i.e., tool calls).
         kwargs
             Additional keyword arguments to pass to the method used for requesting
             the response.
@@ -695,24 +772,26 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
 
         display = self._markdown_display(echo=echo)
 
-        async def wrapper() -> AsyncGenerator[str, None]:
+        async def wrapper() -> AsyncGenerator[
+            str | ContentToolRequest | ContentToolResult, None
+        ]:
             with display:
                 async for chunk in self._chat_impl_async(
                     turn,
                     stream=True,
-                    display=display,
                     echo=echo,
+                    content=content,
                     kwargs=kwargs,
                 ):
                     yield chunk
 
-        return ChatResponseAsync(wrapper())
+        return wrapper()
 
     def extract_data(
         self,
         *args: Content | str,
         data_model: type[BaseModel],
-        echo: Literal["text", "all", "none"] = "none",
+        echo: EchoOptions = "none",
         stream: bool = False,
     ) -> dict[str, Any]:
         """
@@ -742,7 +821,6 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
                 user_turn(*args),
                 data_model=data_model,
                 echo=echo,
-                display=display,
                 stream=stream,
             )
         )
@@ -771,7 +849,7 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         self,
         *args: Content | str,
         data_model: type[BaseModel],
-        echo: Literal["text", "all", "none"] = "none",
+        echo: EchoOptions = "none",
         stream: bool = False,
     ) -> dict[str, Any]:
         """
@@ -802,7 +880,6 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
                 user_turn(*args),
                 data_model=data_model,
                 echo=echo,
-                display=display,
                 stream=stream,
             )
         )
@@ -910,13 +987,65 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         tool = Tool(func, model=model)
         self._tools[tool.name] = tool
 
+    @property
+    def current_display(self) -> Optional[MarkdownDisplay]:
+        """
+        Get the currently active markdown display, if any.
+
+        The display represents the place where `.chat(echo)` content is
+        being displayed. In a notebook/Quarto, this is a wrapper around
+        `IPython.display`. Otherwise, it is a wrapper around a
+        `rich.live.Live()` console.
+
+        This is primarily useful if you want to add custom content to the
+        display while the chat is running, but currently blocked by something
+        like a tool call.
+
+        Example
+        -------
+        ```python
+        import requests
+        from chatlas import ChatOpenAI
+
+        chat = ChatOpenAI()
+
+
+        def get_current_weather(latitude: float, longitude: float):
+            "Get the current weather given a latitude and longitude."
+
+            lat_lng = f"latitude={latitude}&longitude={longitude}"
+            url = f"https://api.open-meteo.com/v1/forecast?{lat_lng}&current=temperature_2m,wind_speed_10m&hourly=temperature_2m,relative_humidity_2m,wind_speed_10m"
+            response = requests.get(url)
+            json = response.json()
+            if chat.current_display:
+                chat.current_display.echo("My custom tool display!!!")
+            return json["current"]
+
+
+        chat.register_tool(get_current_weather)
+
+        chat.chat("What's the current temperature in Duluth, MN?", echo="text")
+        ```
+
+
+        Returns
+        -------
+        Optional[MarkdownDisplay]
+            The currently active markdown display, if any.
+        """
+        return self._current_display
+
+    def _echo_content(self, x: str):
+        if self._current_display:
+            self._current_display.echo(x)
+
     def export(
         self,
         filename: str | Path,
         *,
         turns: Optional[Sequence[Turn]] = None,
         title: Optional[str] = None,
-        include: Literal["text", "all"] = "text",
+        content: Literal["text", "all"] = "text",
         include_system_prompt: bool = True,
         overwrite: bool = False,
     ):
@@ -935,7 +1064,7 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             A title to place at the top of the exported file.
         overwrite
             Whether to overwrite the file if it already exists.
-        include
+        content
             Whether to include text content, all content (i.e., tool calls), or no
             content.
         include_system_prompt
@@ -971,9 +1100,9 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         for turn in turns:
             turn_content = "\n\n".join(
                 [
-                    str(content).strip()
-                    for content in turn.contents
-                    if include == "all" or isinstance(content, ContentText)
+                    str(x).strip()
+                    for x in turn.contents
+                    if content == "all" or isinstance(x, ContentText)
                 ]
             )
             if is_html:
@@ -1033,51 +1162,130 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         </html>
         """
 
+    @overload
     def _chat_impl(
         self,
         user_turn: Turn,
-        echo: Literal["text", "all", "none"],
-        display: MarkdownDisplay,
+        echo: EchoOptions,
+        content: Literal["text"],
         stream: bool,
         kwargs: Optional[SubmitInputArgsT] = None,
-    ) -> Generator[str, None, None]:
+    ) -> Generator[str, None, None]: ...
+
+    @overload
+    def _chat_impl(
+        self,
+        user_turn: Turn,
+        echo: EchoOptions,
+        content: Literal["all"],
+        stream: bool,
+        kwargs: Optional[SubmitInputArgsT] = None,
+    ) -> Generator[str | ContentToolRequest | ContentToolResult, None, None]: ...
+
+    def _chat_impl(
+        self,
+        user_turn: Turn,
+        echo: EchoOptions,
+        content: Literal["text", "all"],
+        stream: bool,
+        kwargs: Optional[SubmitInputArgsT] = None,
+    ) -> Generator[str | ContentToolRequest | ContentToolResult, None, None]:
         user_turn_result: Turn | None = user_turn
         while user_turn_result is not None:
             for chunk in self._submit_turns(
                 user_turn_result,
                 echo=echo,
-                display=display,
                 stream=stream,
                 kwargs=kwargs,
             ):
                 yield chunk
-            user_turn_result = self._invoke_tools()
+
+            turn = self.get_last_turn(role="assistant")
+            assert turn is not None
+            user_turn_result = None
+
+            results: list[ContentToolResult] = []
+            for x in turn.contents:
+                if isinstance(x, ContentToolRequest):
+                    if echo == "output":
+                        self._echo_content(f"\n\n{x}\n\n")
+                    if content == "all":
+                        yield x
+                    res = self._invoke_tool(x)
+                    if echo == "output":
+                        self._echo_content(f"\n\n{res}\n\n")
+                    if content == "all":
+                        yield res
+                    results.append(res)
+
+            if results:
+                user_turn_result = Turn("user", results)
+
+    @overload
+    def _chat_impl_async(
+        self,
+        user_turn: Turn,
+        echo: EchoOptions,
+        content: Literal["text"],
+        stream: bool,
+        kwargs: Optional[SubmitInputArgsT] = None,
+    ) -> AsyncGenerator[str, None]: ...
+
+    @overload
+    def _chat_impl_async(
+        self,
+        user_turn: Turn,
+        echo: EchoOptions,
+        content: Literal["all"],
+        stream: bool,
+        kwargs: Optional[SubmitInputArgsT] = None,
+    ) -> AsyncGenerator[str | ContentToolRequest | ContentToolResult, None]: ...
 
     async def _chat_impl_async(
         self,
         user_turn: Turn,
-        echo: Literal["text", "all", "none"],
-        display: MarkdownDisplay,
+        echo: EchoOptions,
+        content: Literal["text", "all"],
         stream: bool,
         kwargs: Optional[SubmitInputArgsT] = None,
-    ) -> AsyncGenerator[str, None]:
+    ) -> AsyncGenerator[str | ContentToolRequest | ContentToolResult, None]:
         user_turn_result: Turn | None = user_turn
         while user_turn_result is not None:
             async for chunk in self._submit_turns_async(
                 user_turn_result,
                 echo=echo,
-                display=display,
                 stream=stream,
                 kwargs=kwargs,
             ):
                 yield chunk
-            user_turn_result = await self._invoke_tools_async()
+
+            turn = self.get_last_turn(role="assistant")
+            assert turn is not None
+            user_turn_result = None
+
+            results: list[ContentToolResult] = []
+            for x in turn.contents:
+                if isinstance(x, ContentToolRequest):
+                    if echo == "output":
+                        self._echo_content(f"\n\n{x}\n\n")
+                    if content == "all":
+                        yield x
+                    res = await self._invoke_tool_async(x)
+                    if echo == "output":
+                        self._echo_content(f"\n\n{res}\n\n")
+                    if content == "all":
+                        yield res
+                    else:
+                        yield "\n\n"
+                    results.append(res)
+
+            if results:
+                user_turn_result = Turn("user", results)
 
     def _submit_turns(
         self,
         user_turn: Turn,
-        echo: Literal["text", "all", "none"],
-        display: MarkdownDisplay,
+        echo: EchoOptions,
         stream: bool,
         data_model: type[BaseModel] | None = None,
         kwargs: Optional[SubmitInputArgsT] = None,
@@ -1086,7 +1294,7 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             raise ValueError("Cannot use async tools in a synchronous chat")
 
         def emit(text: str | Content):
-            display.update(str(text))
+            self._echo_content(str(text))
 
         emit("<br>\n\n")
 
@@ -1142,14 +1350,13 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
     async def _submit_turns_async(
         self,
         user_turn: Turn,
-        echo: Literal["text", "all", "none"],
-        display: MarkdownDisplay,
+        echo: EchoOptions,
         stream: bool,
         data_model: type[BaseModel] | None = None,
         kwargs: Optional[SubmitInputArgsT] = None,
     ) -> AsyncGenerator[str, None]:
         def emit(text: str | Content):
-            display.update(str(text))
+            self._echo_content(str(text))
 
         emit("<br>\n\n")
 
@@ -1202,92 +1409,74 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
 
         self._turns.extend([user_turn, turn])
 
-    def _invoke_tools(self) -> Turn | None:
-        turn = self.get_last_turn()
-        if turn is None:
-            return None
-
-        results: list[ContentToolResult] = []
-        for x in turn.contents:
-            if isinstance(x, ContentToolRequest):
-                tool_def = self._tools.get(x.name, None)
-                func = tool_def.func if tool_def is not None else None
-                results.append(self._invoke_tool(func, x.arguments, x.id))
-
-        if not results:
-            return None
-
-        return Turn("user", results)
-
-    async def _invoke_tools_async(self) -> Turn | None:
-        turn = self.get_last_turn()
-        if turn is None:
-            return None
-
-        results: list[ContentToolResult] = []
-        for x in turn.contents:
-            if isinstance(x, ContentToolRequest):
-                tool_def = self._tools.get(x.name, None)
-                func = None
-                if tool_def:
-                    if tool_def._is_async:
-                        func = tool_def.func
-                    else:
-                        func = wrap_async(tool_def.func)
-                results.append(await self._invoke_tool_async(func, x.arguments, x.id))
-
-        if not results:
-            return None
+    def _invoke_tool(self, x: ContentToolRequest) -> ContentToolResult:
+        tool_def = self._tools.get(x.name, None)
+        func = tool_def.func if tool_def is not None else None
 
-        return Turn("user", results)
-
-    @staticmethod
-    def _invoke_tool(
-        func: Callable[..., Any] | None,
-        arguments: object,
-        id_: str,
-    ) -> ContentToolResult:
         if func is None:
-            return ContentToolResult(id=id_, value=None, error="Unknown tool")
+            e = RuntimeError(f"Unknown tool: {x.name}")
+            return ContentToolResult(value=None, error=e, request=x)
 
-        name = func.__name__
+        args = x.arguments
 
         try:
-            if isinstance(arguments, dict):
-                result = func(**arguments)
+            if isinstance(args, dict):
+                result = func(**args)
             else:
-                result = func(arguments)
+                result = func(args)
 
-            return ContentToolResult(id=id_, value=result, error=None, name=name)
+            if not isinstance(result, ContentToolResult):
+                result = ContentToolResult(value=result)
+
+            result.request = x
+            return result
         except Exception as e:
-            log_tool_error(name, str(arguments), e)
-            return ContentToolResult(id=id_, value=None, error=str(e), name=name)
+            warnings.warn(
+                f"Calling tool '{x.name}' led to an error.",
+                ToolFailureWarning,
+                stacklevel=2,
+            )
+            traceback.print_exc()
+            log_tool_error(x.name, str(args), e)
+            return ContentToolResult(value=None, error=e, request=x)
+
+    async def _invoke_tool_async(self, x: ContentToolRequest) -> ContentToolResult:
+        tool_def = self._tools.get(x.name, None)
+        func = None
+        if tool_def:
+            if tool_def._is_async:
+                func = tool_def.func
+            else:
+                func = wrap_async(tool_def.func)
 
-    @staticmethod
-    async def _invoke_tool_async(
-        func: Callable[..., Awaitable[Any]] | None,
-        arguments: object,
-        id_: str,
-    ) -> ContentToolResult:
         if func is None:
-            return ContentToolResult(id=id_, value=None, error="Unknown tool")
+            e = RuntimeError(f"Unknown tool: {x.name}")
+            return ContentToolResult(value=None, error=e, request=x)
 
-        name = func.__name__
+        args = x.arguments
 
         try:
-            if isinstance(arguments, dict):
-                result = await func(**arguments)
+            if isinstance(args, dict):
+                result = await func(**args)
             else:
-                result = await func(arguments)
+                result = await func(args)
 
-            return ContentToolResult(id=id_, value=result, error=None, name=name)
+            if not isinstance(result, ContentToolResult):
+                result = ContentToolResult(value=result)
+
+            result.request = x
+            return result
         except Exception as e:
-            log_tool_error(func.__name__, str(arguments), e)
-            return ContentToolResult(id=id_, value=None, error=str(e), name=name)
+            warnings.warn(
+                f"Calling tool '{x.name}' led to an error.",
+                ToolFailureWarning,
+                stacklevel=2,
+            )
+            traceback.print_exc()
+            log_tool_error(x.name, str(args), e)
+            return ContentToolResult(value=None, error=e, request=x)
 
-    def _markdown_display(
-        self, echo: Literal["text", "all", "none"]
-    ) -> MarkdownDisplay:
+    def _markdown_display(self, echo: EchoOptions) -> ChatMarkdownDisplay:
         """
         Get a markdown display object based on the echo option.
 
@@ -1296,7 +1485,7 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         screen sizes.
         """
         if echo == "none":
-            return MockMarkdownDisplay()
+            return ChatMarkdownDisplay(MockMarkdownDisplay(), self)
 
         # rich does a lot to detect a notebook environment, but it doesn't
         # detect Quarto (at least not yet).
@@ -1305,10 +1494,13 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         is_web = Console().is_jupyter or os.getenv("QUARTO_PYTHON", None) is not None
 
         opts = self._echo_options
+
         if is_web:
-            return IPyMarkdownDisplay(opts)
+            display = IPyMarkdownDisplay(opts)
         else:
-            return LiveMarkdownDisplay(opts)
+            display = LiveMarkdownDisplay(opts)
+
+        return ChatMarkdownDisplay(display, self)
 
     def set_echo_options(
         self,
@@ -1331,7 +1523,7 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             A dictionary of CSS styles to apply to `IPython.display.Markdown()`.
             This is only relevant when outputing to the browser.
         """
-        self._echo_options: EchoOptions = {
+        self._echo_options: EchoDisplayOptions = {
             "rich_markdown": rich_markdown or {},
             "rich_console": rich_console or {},
             "css_styles": css_styles or {},
@@ -1501,3 +1693,30 @@ def emit_other_contents(
     to_emit.reverse()
 
     emit("\n\n".join(to_emit))
+
+
+# Helper/wrapper class to let Chat know about the currently active display
+class ChatMarkdownDisplay:
+    def __init__(self, display: MarkdownDisplay, chat: Chat):
+        self._display = display
+        self._chat = chat
+
+    def __enter__(self):
+        self._chat._current_display = self._display
+        return self._display.__enter__()
+
+    def __exit__(self, *args, **kwargs):
+        result = self._display.__exit__(*args, **kwargs)
+        self._chat._current_display = None
+        return result
+
+    def append(self, content):
+        return self._display.echo(content)
+
+
+class ToolFailureWarning(RuntimeWarning):
+    pass
+
+
+# By default warnings are shown once; we want to always show them.
+warnings.simplefilter("always", ToolFailureWarning)