chatlas 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

chatlas/_anthropic.py

@@ -20,7 +20,7 @@ from ._logging import log_model_default
 from ._provider import Provider
 from ._tokens import tokens_log
 from ._tools import Tool, basemodel_to_param_schema
-from ._turn import Turn, normalize_turns
+from ._turn import Turn, normalize_turns, user_turn
 
 if TYPE_CHECKING:
     from anthropic.types import (
@@ -380,6 +380,59 @@ class AnthropicProvider(Provider[Message, RawMessageStreamEvent, Message]):
     def value_turn(self, completion, has_data_model) -> Turn:
         return self._as_turn(completion, has_data_model)
 
+    def token_count(
+        self,
+        *args: Content | str,
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]],
+    ) -> int:
+        kwargs = self._token_count_args(
+            *args,
+            tools=tools,
+            data_model=data_model,
+        )
+        res = self._client.messages.count_tokens(**kwargs)
+        return res.input_tokens
+
+    async def token_count_async(
+        self,
+        *args: Content | str,
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]],
+    ) -> int:
+        kwargs = self._token_count_args(
+            *args,
+            tools=tools,
+            data_model=data_model,
+        )
+        res = await self._async_client.messages.count_tokens(**kwargs)
+        return res.input_tokens
+
+    def _token_count_args(
+        self,
+        *args: Content | str,
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]],
+    ) -> dict[str, Any]:
+        turn = user_turn(*args)
+
+        kwargs = self._chat_perform_args(
+            stream=False,
+            turns=[turn],
+            tools=tools,
+            data_model=data_model,
+        )
+
+        args_to_keep = [
+            "messages",
+            "model",
+            "system",
+            "tools",
+            "tool_choice",
+        ]
+
+        return {arg: kwargs[arg] for arg in args_to_keep if arg in kwargs}
+
     def _as_message_params(self, turns: list[Turn]) -> list["MessageParam"]:
         messages: list["MessageParam"] = []
         for turn in turns:
@@ -575,6 +628,53 @@ def ChatBedrockAnthropic(
         Additional arguments to pass to the `anthropic.AnthropicBedrock()`
         client constructor.
 
+    Troubleshooting
+    ---------------
+
+    If you encounter 400 or 403 errors when trying to use the model, keep the
+    following in mind:
+
+    ::: {.callout-note}
+    #### Incorrect model name
+
+    If the model name is completely incorrect, you'll see an error like
+    `Error code: 400 - {'message': 'The provided model identifier is invalid.'}`
+
+    Make sure the model name is correct and active in the specified region.
+    :::
+
+    ::: {.callout-note}
+    #### Models are region specific
+
+    If you encounter errors similar to `Error code: 403 - {'message': "You don't
+    have access to the model with the specified model ID."}`, make sure your
+    model is active in the relevant `aws_region`.
+
+    Keep in mind, if `aws_region` is not specified, and AWS_REGION is not set,
+    the region defaults to us-east-1, which may not match to your AWS config's
+    default region.
+    :::
+
+    ::: {.callout-note}
+    #### Cross region inference ID
+
+    In some cases, even if you have the right model and the right region, you
+    may still encounter an error like  `Error code: 400 - {'message':
+    'Invocation of model ID anthropic.claude-3-5-sonnet-20240620-v1:0 with
+    on-demand throughput isn't supported. Retry your request with the ID or ARN
+    of an inference profile that contains this model.'}`
+
+    In this case, you'll need to look up the 'cross region inference ID' for
+    your model. This might required opening your `aws-console` and navigating to
+    the 'Anthropic Bedrock' service page. From there, go to the 'cross region
+    inference' tab and copy the relevant ID.
+
+    For example, if the desired model ID is
+    `anthropic.claude-3-5-sonnet-20240620-v1:0`, the cross region ID might look
+    something like `us.anthropic.claude-3-5-sonnet-20240620-v1:0`.
+    :::
+
+
     Returns
     -------
     Chat

chatlas/_chat.py

@@ -16,6 +16,7 @@ from typing import (
     Optional,
     Sequence,
     TypeVar,
+    overload,
 )
 
 from pydantic import BaseModel
@@ -176,17 +177,209 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         if value is not None:
             self._turns.insert(0, Turn("system", value))
 
-    def tokens(self) -> list[tuple[int, int] | None]:
+    @overload
+    def tokens(self) -> list[tuple[int, int] | None]: ...
+
+    @overload
+    def tokens(
+        self,
+        values: Literal["cumulative"],
+    ) -> list[tuple[int, int] | None]: ...
+
+    @overload
+    def tokens(
+        self,
+        values: Literal["discrete"],
+    ) -> list[int]: ...
+
+    def tokens(
+        self,
+        values: Literal["cumulative", "discrete"] = "discrete",
+    ) -> list[int] | list[tuple[int, int] | None]:
         """
         Get the tokens for each turn in the chat.
 
+        Parameters
+        ----------
+        values
+            If "cumulative" (the default), the result can be summed to get the
+            chat's overall token usage (helpful for computing overall cost of
+            the chat). If "discrete", the result can be summed to get the number of
+            tokens the turns will cost to generate the next response (helpful
+            for estimating cost of the next response, or for determining if you
+            are about to exceed the token limit).
+
+        Returns
+        -------
+        list[int]
+            A list of token counts for each (non-system) turn in the chat. The
+            1st turn includes the tokens count for the system prompt (if any).
+
+        Raises
+        ------
+        ValueError
+            If the chat's turns (i.e., `.get_turns()`) are not in an expected
+            format. This may happen if the chat history is manually set (i.e.,
+            `.set_turns()`). In this case, you can inspect the "raw" token
+            values via the `.get_turns()` method (each turn has a `.tokens`
+            attribute).
+        """
+
+        turns = self.get_turns(include_system_prompt=False)
+
+        if values == "cumulative":
+            return [turn.tokens for turn in turns]
+
+        if len(turns) == 0:
+            return []
+
+        err_info = (
+            "This can happen if the chat history is manually set (i.e., `.set_turns()`). "
+            "Consider getting the 'raw' token values via the `.get_turns()` method "
+            "(each turn has a `.tokens` attribute)."
+        )
+
+        # Sanity checks for the assumptions made to figure out user token counts
+        if len(turns) == 1:
+            raise ValueError(
+                "Expected at least two turns in the chat history. " + err_info
+            )
+
+        if len(turns) % 2 != 0:
+            raise ValueError(
+                "Expected an even number of turns in the chat history. " + err_info
+            )
+
+        if turns[0].role != "user":
+            raise ValueError(
+                "Expected the 1st non-system turn to have role='user'. " + err_info
+            )
+
+        if turns[1].role != "assistant":
+            raise ValueError(
+                "Expected the 2nd turn non-system to have role='assistant'. " + err_info
+            )
+
+        if turns[1].tokens is None:
+            raise ValueError(
+                "Expected the 1st assistant turn to contain token counts. " + err_info
+            )
+
+        res: list[int] = [
+            # Implied token count for the 1st user input
+            turns[1].tokens[0],
+            # The token count for the 1st assistant response
+            turns[1].tokens[1],
+        ]
+        for i in range(1, len(turns) - 1, 2):
+            ti = turns[i]
+            tj = turns[i + 2]
+            if ti.role != "assistant" or tj.role != "assistant":
+                raise ValueError(
+                    "Expected even turns to have role='assistant'." + err_info
+                )
+            if ti.tokens is None or tj.tokens is None:
+                raise ValueError(
+                    "Expected role='assistant' turns to contain token counts."
+                    + err_info
+                )
+            res.extend(
+                [
+                    # Implied token count for the user input
+                    tj.tokens[0] - sum(ti.tokens),
+                    # The token count for the assistant response
+                    tj.tokens[1],
+                ]
+            )
+
+        return res
+
+    def token_count(
+        self,
+        *args: Content | str,
+        data_model: Optional[type[BaseModel]] = None,
+    ) -> int:
+        """
+        Get an estimated token count for the given input.
+
+        Estimate the token size of input content. This can help determine whether input(s)
+        and/or conversation history (i.e., `.get_turns()`) should be reduced in size before
+        sending it to the model.
+
+        Parameters
+        ----------
+        args
+            The input to get a token count for.
+        data_model
+            If the input is meant for data extraction (i.e., `.extract_data()`), then
+            this should be the Pydantic model that describes the structure of the data to
+            extract.
+
+        Returns
+        -------
+        int
+            The token count for the input.
+
+        Note
+        ----
+        Remember that the token count is an estimate. Also, models based on
+        `ChatOpenAI()` currently does not take tools into account when
+        estimating token counts.
+
+        Examples
+        --------
+        ```python
+        from chatlas import ChatAnthropic
+
+        chat = ChatAnthropic()
+        # Estimate the token count before sending the input
+        print(chat.token_count("What is 2 + 2?"))
+
+        # Once input is sent, you can get the actual input and output
+        # token counts from the chat object
+        chat.chat("What is 2 + 2?", echo="none")
+        print(chat.token_usage())
+        ```
+        """
+
+        return self.provider.token_count(
+            *args,
+            tools=self._tools,
+            data_model=data_model,
+        )
+
+    async def token_count_async(
+        self,
+        *args: Content | str,
+        data_model: Optional[type[BaseModel]] = None,
+    ) -> int:
+        """
+        Get an estimated token count for the given input asynchronously.
+
+        Estimate the token size of input content. This can help determine whether input(s)
+        and/or conversation history (i.e., `.get_turns()`) should be reduced in size before
+        sending it to the model.
+
+        Parameters
+        ----------
+        args
+            The input to get a token count for.
+        data_model
+            If this input is meant for data extraction (i.e., `.extract_data_async()`),
+            then this should be the Pydantic model that describes the structure of the data
+            to extract.
+
         Returns
         -------
-        list[tuple[int, int] | None]
-            A list of tuples, where each tuple contains the start and end token
-            indices for a turn.
+        int
+            The token count for the input.
         """
-        return [turn.tokens for turn in self._turns]
+
+        return await self.provider.token_count_async(
+            *args,
+            tools=self._tools,
+            data_model=data_model,
+        )
 
     def app(
         self,

chatlas/_google.py

@@ -17,8 +17,9 @@ from ._content import (
 )
 from ._logging import log_model_default
 from ._provider import Provider
+from ._tokens import tokens_log
 from ._tools import Tool, basemodel_to_param_schema
-from ._turn import Turn, normalize_turns
+from ._turn import Turn, normalize_turns, user_turn
 
 if TYPE_CHECKING:
     from google.generativeai.types.content_types import (
@@ -332,6 +333,55 @@ class GoogleProvider(
     def value_turn(self, completion, has_data_model) -> Turn:
         return self._as_turn(completion, has_data_model)
 
+    def token_count(
+        self,
+        *args: Content | str,
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]],
+    ):
+        kwargs = self._token_count_args(
+            *args,
+            tools=tools,
+            data_model=data_model,
+        )
+
+        res = self._client.count_tokens(**kwargs)
+        return res.total_tokens
+
+    async def token_count_async(
+        self,
+        *args: Content | str,
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]],
+    ):
+        kwargs = self._token_count_args(
+            *args,
+            tools=tools,
+            data_model=data_model,
+        )
+
+        res = await self._client.count_tokens_async(**kwargs)
+        return res.total_tokens
+
+    def _token_count_args(
+        self,
+        *args: Content | str,
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]],
+    ) -> dict[str, Any]:
+        turn = user_turn(*args)
+
+        kwargs = self._chat_perform_args(
+            stream=False,
+            turns=[turn],
+            tools=tools,
+            data_model=data_model,
+        )
+
+        args_to_keep = ["contents", "tools"]
+
+        return {arg: kwargs[arg] for arg in args_to_keep if arg in kwargs}
+
     def _google_contents(self, turns: list[Turn]) -> list["ContentDict"]:
         contents: list["ContentDict"] = []
         for turn in turns:
@@ -421,6 +471,8 @@ class GoogleProvider(
             usage.candidates_token_count,
         )
 
+        tokens_log(self, tokens)
+
         finish = message.candidates[0].finish_reason
 
         return Turn(

chatlas/_ollama.py

@@ -48,6 +48,13 @@ def ChatOllama(
     (e.g. `ollama pull llama3.2`).
     :::
 
+    ::: {.callout-note}
+    ## Python requirements
+
+    `ChatOllama` requires the `openai` package (e.g., `pip install openai`).
+    :::
+
+
     Examples
     --------
 
@@ -103,6 +110,7 @@ def ChatOllama(
 
     return ChatOpenAI(
         system_prompt=system_prompt,
+        api_key="ollama",  # ignored
         turns=turns,
         base_url=f"{base_url}/v1",
         model=model,

chatlas/_openai.py

@@ -8,6 +8,7 @@ from pydantic import BaseModel
 from ._chat import Chat
 from ._content import (
     Content,
+    ContentImage,
     ContentImageInline,
     ContentImageRemote,
     ContentJson,
@@ -20,7 +21,7 @@ from ._merge import merge_dicts
 from ._provider import Provider
 from ._tokens import tokens_log
 from ._tools import Tool, basemodel_to_param_schema
-from ._turn import Turn, normalize_turns
+from ._turn import Turn, normalize_turns, user_turn
 from ._utils import MISSING, MISSING_TYPE, is_testing
 
 if TYPE_CHECKING:
@@ -294,10 +295,12 @@ class OpenAIProvider(Provider[ChatCompletion, ChatCompletionChunk, ChatCompletio
             "stream": stream,
             "messages": self._as_message_param(turns),
             "model": self._model,
-            "seed": self._seed,
             **(kwargs or {}),
         }
 
+        if self._seed is not None:
+            kwargs_full["seed"] = self._seed
+
         if tool_schemas:
             kwargs_full["tools"] = tool_schemas
 
@@ -349,6 +352,57 @@ class OpenAIProvider(Provider[ChatCompletion, ChatCompletionChunk, ChatCompletio
     def value_turn(self, completion, has_data_model) -> Turn:
         return self._as_turn(completion, has_data_model)
 
+    def token_count(
+        self,
+        *args: Content | str,
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]],
+    ) -> int:
+        try:
+            import tiktoken
+        except ImportError:
+            raise ImportError(
+                "The tiktoken package is required for token counting. "
+                "Please install it with `pip install tiktoken`."
+            )
+
+        encoding = tiktoken.encoding_for_model(self._model)
+
+        turn = user_turn(*args)
+
+        # Count the tokens in image contents
+        image_tokens = sum(
+            self._image_token_count(x)
+            for x in turn.contents
+            if isinstance(x, ContentImage)
+        )
+
+        # For other contents, get the token count from the actual message param
+        other_contents = [x for x in turn.contents if not isinstance(x, ContentImage)]
+        other_full = self._as_message_param([Turn("user", other_contents)])
+        other_tokens = len(encoding.encode(str(other_full)))
+
+        return other_tokens + image_tokens
+
+    async def token_count_async(
+        self,
+        *args: Content | str,
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]],
+    ) -> int:
+        return self.token_count(*args, tools=tools, data_model=data_model)
+
+    @staticmethod
+    def _image_token_count(image: ContentImage) -> int:
+        if isinstance(image, ContentImageRemote) and image.detail == "low":
+            return 85
+        else:
+            # This is just the max token count for an image The highest possible
+            # resolution is 768 x 2048, and 8 tiles of size 512px can fit inside
+            # TODO: this is obviously a very conservative estimate and could be improved
+            # https://platform.openai.com/docs/guides/vision/calculating-costs
+            return 170 * 8 + 85
+
     @staticmethod
     def _as_message_param(turns: list[Turn]) -> list["ChatCompletionMessageParam"]:
         from openai.types.chat import (
@@ -412,7 +466,13 @@ class OpenAIProvider(Provider[ChatCompletion, ChatCompletionChunk, ChatCompletio
                         contents.append({"type": "text", "text": ""})
                     elif isinstance(x, ContentImageRemote):
                         contents.append(
-                            {"type": "image_url", "image_url": {"url": x.url}}
+                            {
+                                "type": "image_url",
+                                "image_url": {
+                                    "url": x.url,
+                                    "detail": x.detail,
+                                },
+                            }
                         )
                     elif isinstance(x, ContentImageInline):
                         contents.append(

chatlas/_provider.py

@@ -14,6 +14,7 @@ from typing import (
 
 from pydantic import BaseModel
 
+from ._content import Content
 from ._tools import Tool
 from ._turn import Turn
 
@@ -141,3 +142,19 @@ class Provider(
         completion: ChatCompletionT,
         has_data_model: bool,
     ) -> Turn: ...
+
+    @abstractmethod
+    def token_count(
+        self,
+        *args: Content | str,
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]],
+    ) -> int: ...
+
+    @abstractmethod
+    async def token_count_async(
+        self,
+        *args: Content | str,
+        tools: dict[str, Tool],
+        data_model: Optional[type[BaseModel]],
+    ) -> int: ...

chatlas/types/anthropic/_client.py

@@ -18,12 +18,4 @@ class ChatClientArgs(TypedDict, total=False):
     default_headers: Optional[Mapping[str, str]]
     default_query: Optional[Mapping[str, object]]
     http_client: httpx.AsyncClient
-    transport: httpx.AsyncBaseTransport
-    proxies: Union[
-        str,
-        httpx.Proxy,
-        dict[str | httpx.URL, Union[None, str, httpx.URL, httpx.Proxy]],
-        None,
-    ]
-    connection_pool_limits: httpx.Limits
     _strict_response_validation: bool

chatlas/types/anthropic/_submit.py

@@ -6,7 +6,6 @@
 from typing import Iterable, Literal, Mapping, Optional, TypedDict, Union
 
 import anthropic
-import anthropic._types
 import anthropic.types.message_param
 import anthropic.types.text_block_param
 import anthropic.types.tool_choice_any_param
@@ -51,7 +50,7 @@ class SubmitInputArgs(TypedDict, total=False):
     tools: Union[Iterable[anthropic.types.tool_param.ToolParam], anthropic.NotGiven]
     top_k: int | anthropic.NotGiven
     top_p: float | anthropic.NotGiven
-    extra_headers: Optional[Mapping[str, Union[str, anthropic._types.Omit]]]
+    extra_headers: Optional[Mapping[str, Union[str, anthropic.Omit]]]
     extra_query: Optional[Mapping[str, object]]
     extra_body: object | None
     timeout: float | anthropic.Timeout | None | anthropic.NotGiven

chatlas/types/openai/_client.py

@@ -14,6 +14,7 @@ class ChatClientArgs(TypedDict, total=False):
     organization: str | None
     project: str | None
     base_url: str | httpx.URL | None
+    websocket_base_url: str | httpx.URL | None
     timeout: Union[float, openai.Timeout, None, openai.NotGiven]
     max_retries: int
     default_headers: Optional[Mapping[str, str]]

chatlas/types/openai/_client_azure.py

@@ -17,6 +17,7 @@ class ChatAzureClientArgs(TypedDict, total=False):
     organization: str | None
     project: str | None
     base_url: str | None
+    websocket_base_url: str | httpx.URL | None
     timeout: float | openai.Timeout | None | openai.NotGiven
     max_retries: int
     default_headers: Optional[Mapping[str, str]]

chatlas/types/openai/_submit.py

@@ -8,6 +8,7 @@ from typing import Iterable, Literal, Mapping, Optional, TypedDict, Union
 import openai
 import openai.types.chat.chat_completion_assistant_message_param
 import openai.types.chat.chat_completion_audio_param
+import openai.types.chat.chat_completion_developer_message_param
 import openai.types.chat.chat_completion_function_call_option_param
 import openai.types.chat.chat_completion_function_message_param
 import openai.types.chat.chat_completion_named_tool_choice_param
@@ -26,6 +27,7 @@ import openai.types.shared_params.response_format_text
 class SubmitInputArgs(TypedDict, total=False):
     messages: Iterable[
         Union[
+            openai.types.chat.chat_completion_developer_message_param.ChatCompletionDeveloperMessageParam,
             openai.types.chat.chat_completion_system_message_param.ChatCompletionSystemMessageParam,
             openai.types.chat.chat_completion_user_message_param.ChatCompletionUserMessageParam,
             openai.types.chat.chat_completion_assistant_message_param.ChatCompletionAssistantMessageParam,
@@ -36,6 +38,8 @@ class SubmitInputArgs(TypedDict, total=False):
     model: Union[
         str,
         Literal[
+            "o1",
+            "o1-2024-12-17",
             "o1-preview",
             "o1-preview-2024-09-12",
             "o1-mini",
@@ -44,10 +48,11 @@ class SubmitInputArgs(TypedDict, total=False):
             "gpt-4o-2024-11-20",
             "gpt-4o-2024-08-06",
             "gpt-4o-2024-05-13",
-            "gpt-4o-realtime-preview",
-            "gpt-4o-realtime-preview-2024-10-01",
             "gpt-4o-audio-preview",
             "gpt-4o-audio-preview-2024-10-01",
+            "gpt-4o-audio-preview-2024-12-17",
+            "gpt-4o-mini-audio-preview",
+            "gpt-4o-mini-audio-preview-2024-12-17",
             "chatgpt-4o-latest",
             "gpt-4o-mini",
             "gpt-4o-mini-2024-07-18",
@@ -100,6 +105,7 @@ class SubmitInputArgs(TypedDict, total=False):
         openai.NotGiven,
     ]
     presence_penalty: Union[float, None, openai.NotGiven]
+    reasoning_effort: Union[Literal["low", "medium", "high"], openai.NotGiven]
     response_format: Union[
         openai.types.shared_params.response_format_text.ResponseFormatText,
         openai.types.shared_params.response_format_json_object.ResponseFormatJSONObject,

{chatlas-0.2.0.dist-info → chatlas-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: chatlas
-Version: 0.2.0
+Version: 0.3.0
 Summary: A simple and consistent interface for chatting with LLMs
 Project-URL: Homepage, https://posit-dev.github.io/chatlas
 Project-URL: Documentation, https://posit-dev.github.io/chatlas
@@ -30,15 +30,18 @@ Requires-Dist: pillow; extra == 'dev'
 Requires-Dist: python-dotenv; extra == 'dev'
 Requires-Dist: ruff>=0.6.5; extra == 'dev'
 Requires-Dist: shiny; extra == 'dev'
+Requires-Dist: tiktoken; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: griffe>=1; extra == 'docs'
 Requires-Dist: ipykernel; extra == 'docs'
 Requires-Dist: ipywidgets; extra == 'docs'
 Requires-Dist: nbclient; extra == 'docs'
 Requires-Dist: nbformat; extra == 'docs'
+Requires-Dist: numpy; extra == 'docs'
 Requires-Dist: pandas; extra == 'docs'
 Requires-Dist: pyyaml; extra == 'docs'
 Requires-Dist: quartodoc>=0.7; extra == 'docs'
+Requires-Dist: sentence-transformers; extra == 'docs'
 Provides-Extra: test
 Requires-Dist: pyright>=1.1.379; extra == 'test'
 Requires-Dist: pytest-asyncio; extra == 'test'
@@ -48,6 +51,14 @@ Description-Content-Type: text/markdown
 
 # chatlas
 
+<p>
+<!-- badges start -->
+<a href="https://pypi.org/project/chatlas/"><img alt="PyPI" src="https://img.shields.io/pypi/v/chatlas?logo=python&logoColor=white&color=orange"></a>
+<a href="https://choosealicense.com/licenses/mit/"><img src="https://img.shields.io/badge/License-MIT-blue.svg" alt="MIT License"></a>
+<a href="https://github.com/posit-dev/chatlas"><img src="https://github.com/posit-dev/chatlas/actions/workflows/test.yml/badge.svg?branch=main" alt="Python Tests"></a>
+<!-- badges end -->
+</p>
+
 chatlas provides a simple and unified interface across large language model (llm) providers in Python. 
 It abstracts away complexity from common tasks like streaming chat interfaces, tool calling, structured output, and much more.
 chatlas helps you prototype faster without painting you into a corner; for example, switching providers is as easy as changing one line of code, but provider specific features are still accessible when needed.
@@ -123,7 +134,7 @@ From a `chat` instance, it's simple to start a web-based or terminal-based chat
 chat.app()
 ```
 
-<div style="display:flex;justify-content:center;">
+<div align="center">
 <img width="500" alt="A web app for chatting with an LLM via chatlas" src="https://github.com/user-attachments/assets/e43f60cb-3686-435a-bd11-8215cb024d2e" class="border rounded">
 </div>
 
@@ -279,7 +290,7 @@ asyncio.run(main())
 
 `chatlas` has full typing support, meaning that, among other things, autocompletion just works in your favorite editor:
 
-<div style="display:flex;justify-content:center;">
+<div align="center">
 <img width="500" alt="Autocompleting model options in ChatOpenAI" src="https://github.com/user-attachments/assets/163d6d8a-7d58-422d-b3af-cc9f2adee759" class="rounded">
 </div>
 
@@ -299,7 +310,7 @@ This shows important information like tool call results, finish reasons, and mor
 If the problem isn't self-evident, you can also reach into the `.get_last_turn()`, which contains the full response object, with full details about the completion.
 
 
-<div style="display:flex;justify-content:center;">
+<div align="center">
   <img width="500" alt="Turn completion details with typing support" src="https://github.com/user-attachments/assets/eaea338d-e44a-4e23-84a7-2e998d8af3ba" class="rounded">
 </div>
 

{chatlas-0.2.0.dist-info → chatlas-0.3.0.dist-info}/RECORD

@@ -1,19 +1,19 @@
 chatlas/__init__.py,sha256=OJbTO71ne1O9SDxkwIKOMpCMKbh0T8eDpYPFhrAb28A,974
-chatlas/_anthropic.py,sha256=AUb1ZJfZo6AEVwfNrMl520-zGomkOfc-ewJoFXGGEEc,21180
-chatlas/_chat.py,sha256=_WTqI3v84voJ9GJJlizIPjxomx3O--fToN5NQSGeFuM,38452
+chatlas/_anthropic.py,sha256=ssv6k-XZetwv1hNk7Qs8dAWlcPvElzxjrG0Fh2w50xE,24373
+chatlas/_chat.py,sha256=p_MS1LQ-EBlvCzGTbjY5Bdlt1meDsfSbP517blkwSjY,44774
 chatlas/_content.py,sha256=vpWF_WKS2tCDUtnL8l9lfW6b6g9e7LbDKP-_TegauVE,5883
 chatlas/_content_image.py,sha256=4nk9wTvLtNmtcytdFp8p9otEV5-0_K6wzIxCyK0PIEI,8367
 chatlas/_display.py,sha256=_IcQcvpyTNjGHOpY70_LOrDWwTjzdkziy6pTvxHEiWI,4053
 chatlas/_github.py,sha256=D3L7Qu35K-M1qEW7-w-Oq-pF-9mVetia3MHYNNLEYtU,4373
-chatlas/_google.py,sha256=Y3vFcUKyEiTAGUkh6Nhw8pbsDYSN3xAECXc9jpd7-6A,13953
+chatlas/_google.py,sha256=jfBp_C_qjbvs48QPE_ykSsfRhjz7htb-G389qLxvSC4,15279
 chatlas/_groq.py,sha256=3VnYiKdxJTHPhEgUKnL2nY5uYL2L4PKBo7GZMwR0D8k,4158
 chatlas/_interpolate.py,sha256=ykwLP3x-ya9Q33U4knSU75dtk6pzJAeythEEIW-43Pc,3631
 chatlas/_logging.py,sha256=7a20sAl1PkW1qBNrfd_ieUbQXV8Gf4Vuf0Wn62LNBmk,2290
 chatlas/_merge.py,sha256=Xt2uutLdEmYAGfGCa8GCEd8sdNadQM5o3l-zuIQFbWU,3923
-chatlas/_ollama.py,sha256=G1rGasb6cq8WhuvSpo2oHMBkeeguZE_TrurIyZSIPJ8,3584
-chatlas/_openai.py,sha256=mEeUTcwT7s33CWhAvavferQlc4ltk3Wm75Bqh1jQKw0,21855
+chatlas/_ollama.py,sha256=ze-RoHEbf62dYmXDDKjNGqaEZaKCZdcBEyFwQMDQxkQ,3760
+chatlas/_openai.py,sha256=nJgp3JJlpxeXn_dhIrXNffQk9vh3ycYy1D2fNip0qEs,24004
 chatlas/_perplexity.py,sha256=Bw_mlM8N8egGKIrbNerTn2pMlybugADOshjYOfN1ixM,4446
-chatlas/_provider.py,sha256=nUfJEXcVs_Yxns2WLr3BevmAnU19fnIGEK_VAeSyt6E,3601
+chatlas/_provider.py,sha256=i16I2hkBat1fYEMcFsU0gYNr6Tcg8zJ2xHDnEY7WRY4,4009
 chatlas/_tokens.py,sha256=3W3EPUp9eWXUiwuzJwEPBv43AUznbK46pm59Htti7z4,2392
 chatlas/_tokens_old.py,sha256=L9d9oafrXvEx2u4nIn_Jjn7adnQyLBnYBuPwJUE8Pl8,5005
 chatlas/_tools.py,sha256=-qt4U1AFkebQoX9kpsBy5QXK8a2PpHX6Amgm44gcQ68,4113
@@ -22,16 +22,16 @@ chatlas/_typing_extensions.py,sha256=YdzmlyPSBpIEcsOkoz12e6jETT1XEMV2Q72haE4cfwY
 chatlas/_utils.py,sha256=qAiWuDx-uG8BGFZ_PWvum9wpN-WogdItO32X4pRhhLs,2762
 chatlas/types/__init__.py,sha256=pgHl8pd2Ytskd6lkfNtm98Yj1ZP0b3R35RH4Uht2BAs,694
 chatlas/types/anthropic/__init__.py,sha256=OwubA-DPHYpYo0XyRyAFwftOI0mOxtHzAyhUSLcDx54,417
-chatlas/types/anthropic/_client.py,sha256=Iz7U7u7_Af4UzKuDDOaYe09T_WW1w9yXtqxrgn0ITSk,918
+chatlas/types/anthropic/_client.py,sha256=G0LRhoFBcsSOMr5qhP-0rAScsVXaVlHCpggfVp54bnQ,690
 chatlas/types/anthropic/_client_bedrock.py,sha256=mNazQlu0pQt8JdzrYn3LKNgE4n732GjhQUJdQQK9QkY,785
-chatlas/types/anthropic/_submit.py,sha256=MBsKtgPrRq4z_Ls5haT3oZKSTpM0_K9STxJZ_2ge-iA,2122
+chatlas/types/anthropic/_submit.py,sha256=BhkJu0OhIMiD3qiUNqJ4litBQCW-7KRr_YZp9Xr9KGA,2091
 chatlas/types/google/__init__.py,sha256=ZJhi8Kwvio2zp8T1TQqmvdHqkS-Khb6BGESPjREADgo,337
 chatlas/types/google/_client.py,sha256=YA5hsT-m-KcONKtwpCULYMnGwMPfkScpvhjx_qBLg5o,4421
 chatlas/types/google/_submit.py,sha256=yp1wtp5eScLlHDNxeXl0qJOKv7SWLnRQ8oslupRFUBE,4839
 chatlas/types/openai/__init__.py,sha256=Q2RAr1bSH1nHsxICK05nAmKmxdhKmhbBkWD_XHiVSrI,411
-chatlas/types/openai/_client.py,sha256=4V9UcysJI6Iu8CsaFH68EJiGIs-H41veguldsVj4KMA,707
-chatlas/types/openai/_client_azure.py,sha256=zrQv0JZS47UB-ViIOKcFSv8YVJIzaridP_e-FF1f-U4,811
-chatlas/types/openai/_submit.py,sha256=Gl8YPARAY-kChPOdjoyLBEtVgarYrX69OOeFQH6b6cI,5679
-chatlas-0.2.0.dist-info/METADATA,sha256=C1CrsrVrcKI36Wnp2u-samFDFoQ6krG9RnfawFIPzSs,12617
-chatlas-0.2.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-chatlas-0.2.0.dist-info/RECORD,,
+chatlas/types/openai/_client.py,sha256=YGm_EHtRSSHeeOZe-CV7oNvMJpEblEta3UTuU7lSRO8,754
+chatlas/types/openai/_client_azure.py,sha256=jx8D_p46CLDGzTP-k-TtGzj-f3junj6or-86m8DD_0w,858
+chatlas/types/openai/_submit.py,sha256=f2o3rNJZcWBhwjomXrs3Mh0V_4vNa9N5eEBkMvJDofQ,6028
+chatlas-0.3.0.dist-info/METADATA,sha256=eIPyvdcXpYN4s6txY5GMgBttUsmS5868D10U5zzTchs,13164
+chatlas-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+chatlas-0.3.0.dist-info/RECORD,,

{chatlas-0.2.0.dist-info → chatlas-0.3.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.26.3
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any