chatlas 0.9.2__py3-none-any.whl → 0.10.0__py3-none-any.whl

chatlas/__init__.py

@@ -7,13 +7,19 @@ from ._content_pdf import content_pdf_file, content_pdf_url
 from ._interpolate import interpolate, interpolate_file
 from ._provider import Provider
 from ._provider_anthropic import ChatAnthropic, ChatBedrockAnthropic
+from ._provider_cloudflare import ChatCloudflare
 from ._provider_databricks import ChatDatabricks
+from ._provider_deepseek import ChatDeepSeek
 from ._provider_github import ChatGithub
 from ._provider_google import ChatGoogle, ChatVertex
 from ._provider_groq import ChatGroq
+from ._provider_huggingface import ChatHuggingFace
+from ._provider_mistral import ChatMistral
 from ._provider_ollama import ChatOllama
 from ._provider_openai import ChatAzureOpenAI, ChatOpenAI
+from ._provider_openrouter import ChatOpenRouter
 from ._provider_perplexity import ChatPerplexity
+from ._provider_portkey import ChatPortkey
 from ._provider_snowflake import ChatSnowflake
 from ._tokens import token_usage
 from ._tools import Tool, ToolRejectError
@@ -28,14 +34,20 @@ __all__ = (
     "ChatAnthropic",
     "ChatAuto",
     "ChatBedrockAnthropic",
+    "ChatCloudflare",
     "ChatDatabricks",
+    "ChatDeepSeek",
     "ChatGithub",
     "ChatGoogle",
     "ChatGroq",
+    "ChatHuggingFace",
+    "ChatMistral",
     "ChatOllama",
     "ChatOpenAI",
+    "ChatOpenRouter",
     "ChatAzureOpenAI",
     "ChatPerplexity",
+    "ChatPortkey",
     "ChatSnowflake",
     "ChatVertex",
     "Chat",

chatlas/_chat.py

@@ -395,8 +395,8 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
                 )
 
             input_token_price = price_token["input"] / 1e6
-            output_token_price = price_token["output"] / 1e6
-            cached_token_price = price_token["cached_input"] / 1e6
+            output_token_price = price_token.get("output", 0) / 1e6
+            cached_token_price = price_token.get("cached_input", 0) / 1e6
 
         if len(turns_tokens) == 0:
             return 0.0

chatlas/_provider_anthropic.py

@@ -163,7 +163,7 @@ def ChatAnthropic(
     """
 
     if model is None:
-        model = log_model_default("claude-3-7-sonnet-latest")
+        model = log_model_default("claude-sonnet-4-0")
 
     return Chat(
         provider=AnthropicProvider(
@@ -742,8 +742,7 @@ def ChatBedrockAnthropic(
     """
 
     if model is None:
-        # Default model from https://github.com/anthropics/anthropic-sdk-python?tab=readme-ov-file#aws-bedrock
-        model = log_model_default("anthropic.claude-3-5-sonnet-20241022-v2:0")
+        model = log_model_default("us.anthropic.claude-sonnet-4-20250514-v1:0")
 
     return Chat(
         provider=AnthropicBedrockProvider(

chatlas/_provider_cloudflare.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Optional
+
+from ._chat import Chat
+from ._logging import log_model_default
+from ._provider_openai import OpenAIProvider
+from ._utils import MISSING, MISSING_TYPE, is_testing
+
+if TYPE_CHECKING:
+    from ._provider_openai import ChatCompletion
+    from .types.openai import ChatClientArgs, SubmitInputArgs
+
+
+def ChatCloudflare(
+    *,
+    account: Optional[str] = None,
+    system_prompt: Optional[str] = None,
+    model: Optional[str] = None,
+    api_key: Optional[str] = None,
+    seed: Optional[int] | MISSING_TYPE = MISSING,
+    kwargs: Optional["ChatClientArgs"] = None,
+) -> Chat["SubmitInputArgs", ChatCompletion]:
+    """
+    Chat with a model hosted on Cloudflare Workers AI.
+
+    Cloudflare Workers AI hosts a variety of open-source AI models.
+
+    Prerequisites
+    -------------
+
+    ::: {.callout-note}
+    ## API credentials
+
+    To use the Cloudflare API, you must have an Account ID and an Access Token,
+    which you can obtain by following the instructions at
+    <https://developers.cloudflare.com/workers-ai/get-started/rest-api/>.
+    :::
+
+    Examples
+    --------
+
+    ```python
+    import os
+    from chatlas import ChatCloudflare
+
+    chat = ChatCloudflare(
+        api_key=os.getenv("CLOUDFLARE_API_KEY"),
+        account=os.getenv("CLOUDFLARE_ACCOUNT_ID"),
+    )
+    chat.chat("What is the capital of France?")
+    ```
+
+    Known limitations
+    -----------------
+
+    - Tool calling does not appear to work.
+    - Images don't appear to work.
+
+    Parameters
+    ----------
+    account
+        The Cloudflare account ID. You generally should not supply this directly,
+        but instead set the `CLOUDFLARE_ACCOUNT_ID` environment variable.
+    system_prompt
+        A system prompt to set the behavior of the assistant.
+    model
+        The model to use for the chat. The default, None, will pick a reasonable
+        default, and warn you about it. We strongly recommend explicitly choosing
+        a model for all but the most casual use.
+    api_key
+        The API key to use for authentication. You generally should not supply
+        this directly, but instead set the `CLOUDFLARE_API_KEY` environment
+        variable.
+    seed
+        Optional integer seed that ChatGPT uses to try and make output more
+        reproducible.
+    kwargs
+        Additional arguments to pass to the `openai.OpenAI()` client constructor.
+
+    Returns
+    -------
+    Chat
+        A chat object that retains the state of the conversation.
+
+    Note
+    ----
+    This function is a lightweight wrapper around [](`~chatlas.ChatOpenAI`) with
+    the defaults tweaked for Cloudflare.
+
+    Note
+    ----
+    Pasting credentials into a chat constructor (e.g.,
+    `ChatCloudflare(api_key="...", account="...")`) is the simplest way to get
+    started, and is fine for interactive use, but is problematic for code that
+    may be shared with others.
+
+    Instead, consider using environment variables or a configuration file to manage
+    your credentials. One popular way to manage credentials is to use a `.env` file
+    to store your credentials, and then use the `python-dotenv` package to load them
+    into your environment.
+
+    ```shell
+    pip install python-dotenv
+    ```
+
+    ```shell
+    # .env
+    CLOUDFLARE_API_KEY=...
+    CLOUDFLARE_ACCOUNT_ID=...
+    ```
+
+    ```python
+    from chatlas import ChatCloudflare
+    from dotenv import load_dotenv
+
+    load_dotenv()
+    chat = ChatCloudflare()
+    chat.console()
+    ```
+
+    Another, more general, solution is to load your environment variables into the shell
+    before starting Python (maybe in a `.bashrc`, `.zshrc`, etc. file):
+
+    ```shell
+    export CLOUDFLARE_API_KEY=...
+    export CLOUDFLARE_ACCOUNT_ID=...
+    ```
+    """
+    # List at https://developers.cloudflare.com/workers-ai/models/
+    # `@cf` appears to be part of the model name
+    if model is None:
+        model = log_model_default("@cf/meta/llama-3.3-70b-instruct-fp8-fast")
+
+    if api_key is None:
+        api_key = os.getenv("CLOUDFLARE_API_KEY")
+
+    if account is None:
+        account = os.getenv("CLOUDFLARE_ACCOUNT_ID")
+
+    if account is None:
+        raise ValueError(
+            "Cloudflare account ID is required. Set the CLOUDFLARE_ACCOUNT_ID "
+            "environment variable or pass the `account` parameter."
+        )
+
+    if isinstance(seed, MISSING_TYPE):
+        seed = 1014 if is_testing() else None
+
+    # https://developers.cloudflare.com/workers-ai/configuration/open-ai-compatibility/
+    cloudflare_api = "https://api.cloudflare.com/client/v4/accounts"
+    base_url = f"{cloudflare_api}/{account}/ai/v1/"
+
+    return Chat(
+        provider=OpenAIProvider(
+            api_key=api_key,
+            model=model,
+            base_url=base_url,
+            seed=seed,
+            name="Cloudflare",
+            kwargs=kwargs,
+        ),
+        system_prompt=system_prompt,
+    )

chatlas/_provider_databricks.py

@@ -127,3 +127,14 @@ class DatabricksProvider(OpenAIProvider):
             api_key="no-token",  # A placeholder to pass validations, this will not be used
             http_client=httpx.AsyncClient(auth=client._client.auth),
         )
+
+    # Databricks doesn't support stream_options
+    def _chat_perform_args(
+        self, stream, turns, tools, data_model=None, kwargs=None
+    ) -> "SubmitInputArgs":
+        kwargs2 = super()._chat_perform_args(stream, turns, tools, data_model, kwargs)
+
+        if "stream_options" in kwargs2:
+            del kwargs2["stream_options"]
+
+        return kwargs2

chatlas/_provider_deepseek.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Optional, cast
+
+from ._chat import Chat
+from ._logging import log_model_default
+from ._provider_openai import OpenAIProvider
+from ._turn import Turn
+from ._utils import MISSING, MISSING_TYPE, is_testing
+
+if TYPE_CHECKING:
+    from openai.types.chat import ChatCompletion, ChatCompletionMessageParam
+
+    from .types.openai import ChatClientArgs, SubmitInputArgs
+
+
+def ChatDeepSeek(
+    *,
+    system_prompt: Optional[str] = None,
+    model: Optional[str] = None,
+    api_key: Optional[str] = None,
+    base_url: str = "https://api.deepseek.com",
+    seed: Optional[int] | MISSING_TYPE = MISSING,
+    kwargs: Optional["ChatClientArgs"] = None,
+) -> Chat["SubmitInputArgs", ChatCompletion]:
+    """
+    Chat with a model hosted on DeepSeek.
+
+    DeepSeek is a platform for AI inference with competitive pricing
+    and performance.
+
+    Prerequisites
+    -------------
+
+    ::: {.callout-note}
+    ## API key
+
+    Sign up at <https://platform.deepseek.com> to get an API key.
+    :::
+
+    Examples
+    --------
+
+    ```python
+    import os
+    from chatlas import ChatDeepSeek
+
+    chat = ChatDeepSeek(api_key=os.getenv("DEEPSEEK_API_KEY"))
+    chat.chat("What is the capital of France?")
+    ```
+
+    Known limitations
+    --------------
+
+    * Structured data extraction is not supported.
+    * Images are not supported.
+
+    Parameters
+    ----------
+    system_prompt
+        A system prompt to set the behavior of the assistant.
+    model
+        The model to use for the chat. The default, None, will pick a reasonable
+        default, and warn you about it. We strongly recommend explicitly choosing
+        a model for all but the most casual use.
+    api_key
+        The API key to use for authentication. You generally should not supply
+        this directly, but instead set the `DEEPSEEK_API_KEY` environment variable.
+    base_url
+        The base URL to the endpoint; the default uses DeepSeek's API.
+    seed
+        Optional integer seed that DeepSeek uses to try and make output more
+        reproducible.
+    kwargs
+        Additional arguments to pass to the `openai.OpenAI()` client constructor.
+
+    Returns
+    -------
+    Chat
+        A chat object that retains the state of the conversation.
+
+    Note
+    ----
+    This function is a lightweight wrapper around [](`~chatlas.ChatOpenAI`) with
+    the defaults tweaked for DeepSeek.
+
+    Note
+    ----
+    Pasting an API key into a chat constructor (e.g., `ChatDeepSeek(api_key="...")`)
+    is the simplest way to get started, and is fine for interactive use, but is
+    problematic for code that may be shared with others.
+
+    Instead, consider using environment variables or a configuration file to manage
+    your credentials. One popular way to manage credentials is to use a `.env` file
+    to store your credentials, and then use the `python-dotenv` package to load them
+    into your environment.
+
+    ```shell
+    pip install python-dotenv
+    ```
+
+    ```shell
+    # .env
+    DEEPSEEK_API_KEY=...
+    ```
+
+    ```python
+    from chatlas import ChatDeepSeek
+    from dotenv import load_dotenv
+
+    load_dotenv()
+    chat = ChatDeepSeek()
+    chat.console()
+    ```
+
+    Another, more general, solution is to load your environment variables into the shell
+    before starting Python (maybe in a `.bashrc`, `.zshrc`, etc. file):
+
+    ```shell
+    export DEEPSEEK_API_KEY=...
+    ```
+    """
+    if model is None:
+        model = log_model_default("deepseek-chat")
+
+    if api_key is None:
+        api_key = os.getenv("DEEPSEEK_API_KEY")
+
+    if isinstance(seed, MISSING_TYPE):
+        seed = 1014 if is_testing() else None
+
+    return Chat(
+        provider=DeepSeekProvider(
+            api_key=api_key,
+            model=model,
+            base_url=base_url,
+            seed=seed,
+            name="DeepSeek",
+            kwargs=kwargs,
+        ),
+        system_prompt=system_prompt,
+    )
+
+
+class DeepSeekProvider(OpenAIProvider):
+    @staticmethod
+    def _as_message_param(turns: list[Turn]) -> list["ChatCompletionMessageParam"]:
+        from openai.types.chat import (
+            ChatCompletionAssistantMessageParam,
+            ChatCompletionUserMessageParam,
+        )
+
+        params = OpenAIProvider._as_message_param(turns)
+
+        # Content must be a string
+        for i, param in enumerate(params):
+            if param["role"] in ["assistant", "user"]:
+                param = cast(
+                    ChatCompletionAssistantMessageParam
+                    | ChatCompletionUserMessageParam,
+                    param,
+                )
+                contents = param.get("content", None)
+                if not isinstance(contents, list):
+                    continue
+                params[i]["content"] = "".join(
+                    content.get("text", "") for content in contents
+                )
+
+        return params

chatlas/_provider_huggingface.py

@@ -0,0 +1,155 @@
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Optional
+
+from ._chat import Chat
+from ._logging import log_model_default
+from ._provider_openai import OpenAIProvider
+
+if TYPE_CHECKING:
+    from openai.types.chat import ChatCompletion
+
+    from .types.openai import ChatClientArgs, SubmitInputArgs
+
+
+def ChatHuggingFace(
+    *,
+    system_prompt: Optional[str] = None,
+    model: Optional[str] = None,
+    api_key: Optional[str] = None,
+    kwargs: Optional["ChatClientArgs"] = None,
+) -> Chat["SubmitInputArgs", ChatCompletion]:
+    """
+    Chat with a model hosted on Hugging Face Inference API.
+
+    [Hugging Face](https://huggingface.co/) hosts a variety of open-source
+    and proprietary AI models available via their Inference API.
+    To use the Hugging Face API, you must have an Access Token, which you can obtain
+    from your [Hugging Face account](https://huggingface.co/settings/tokens).
+    Ensure that at least "Make calls to Inference Providers" and
+    "Make calls to your Inference Endpoints" is checked.
+
+    Prerequisites
+    --------------
+
+    ::: {.callout-note}
+    ## API key
+
+    You will need to create a Hugging Face account and generate an API token
+    from your [account settings](https://huggingface.co/settings/tokens).
+    Make sure to enable "Make calls to Inference Providers" permission.
+    :::
+
+    Examples
+    --------
+    ```python
+    import os
+    from chatlas import ChatHuggingFace
+
+    chat = ChatHuggingFace(api_key=os.getenv("HUGGINGFACE_API_KEY"))
+    chat.chat("What is the capital of France?")
+    ```
+
+    Parameters
+    ----------
+    system_prompt
+        A system prompt to set the behavior of the assistant.
+    model
+        The model to use for the chat. The default, None, will pick a reasonable
+        default, and warn you about it. We strongly recommend explicitly
+        choosing a model for all but the most casual use.
+    api_key
+        The API key to use for authentication. You generally should not supply
+        this directly, but instead set the `HUGGINGFACE_API_KEY` environment
+        variable.
+    kwargs
+        Additional arguments to pass to the underlying OpenAI client
+        constructor.
+
+    Returns
+    -------
+    Chat
+        A chat object that retains the state of the conversation.
+
+    Known limitations
+    -----------------
+
+    * Some models do not support the chat interface or parts of it, for example
+      `google/gemma-2-2b-it` does not support a system prompt. You will need to
+      carefully choose the model.
+    * Tool calling support varies by model - many models do not support it.
+
+    Note
+    ----
+    This function is a lightweight wrapper around [](`~chatlas.ChatOpenAI`), with
+    the defaults tweaked for Hugging Face.
+
+    Note
+    ----
+    Pasting an API key into a chat constructor (e.g., `ChatHuggingFace(api_key="...")`)
+    is the simplest way to get started, and is fine for interactive use, but is
+    problematic for code that may be shared with others.
+
+    Instead, consider using environment variables or a configuration file to manage
+    your credentials. One popular way to manage credentials is to use a `.env` file
+    to store your credentials, and then use the `python-dotenv` package to load them
+    into your environment.
+
+    ```shell
+    pip install python-dotenv
+    ```
+
+    ```shell
+    # .env
+    HUGGINGFACE_API_KEY=...
+    ```
+
+    ```python
+    from chatlas import ChatHuggingFace
+    from dotenv import load_dotenv
+
+    load_dotenv()
+    chat = ChatHuggingFace()
+    chat.console()
+    ```
+
+    Another, more general, solution is to load your environment variables into the shell
+    before starting Python (maybe in a `.bashrc`, `.zshrc`, etc. file):
+
+    ```shell
+    export HUGGINGFACE_API_KEY=...
+    ```
+    """
+    if api_key is None:
+        api_key = os.getenv("HUGGINGFACE_API_KEY")
+
+    if model is None:
+        model = log_model_default("meta-llama/Llama-3.1-8B-Instruct")
+
+    return Chat(
+        provider=HuggingFaceProvider(
+            api_key=api_key,
+            model=model,
+            kwargs=kwargs,
+        ),
+        system_prompt=system_prompt,
+    )
+
+
+class HuggingFaceProvider(OpenAIProvider):
+    def __init__(
+        self,
+        *,
+        api_key: Optional[str] = None,
+        model: str,
+        kwargs: Optional["ChatClientArgs"] = None,
+    ):
+        # https://huggingface.co/docs/inference-providers/en/index?python-clients=requests#http--curl
+        super().__init__(
+            name="HuggingFace",
+            model=model,
+            api_key=api_key,
+            base_url="https://router.huggingface.co/v1",
+            kwargs=kwargs,
+        )

chatlas/_provider_mistral.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Optional
+
+from ._chat import Chat
+from ._logging import log_model_default
+from ._provider_openai import OpenAIProvider
+from ._utils import MISSING, MISSING_TYPE, is_testing
+
+if TYPE_CHECKING:
+    from openai.types.chat import ChatCompletion
+
+    from .types.openai import ChatClientArgs, SubmitInputArgs
+
+
+def ChatMistral(
+    *,
+    system_prompt: Optional[str] = None,
+    model: Optional[str] = None,
+    api_key: Optional[str] = None,
+    base_url: str = "https://api.mistral.ai/v1/",
+    seed: int | None | MISSING_TYPE = MISSING,
+    kwargs: Optional["ChatClientArgs"] = None,
+) -> Chat["SubmitInputArgs", ChatCompletion]:
+    """
+    Chat with a model hosted on Mistral's La Plateforme.
+
+    Mistral AI provides high-performance language models through their API platform.
+
+    Prerequisites
+    -------------
+
+    ::: {.callout-note}
+    ## API credentials
+
+    Get your API key from https://console.mistral.ai/api-keys.
+    :::
+
+    Examples
+    --------
+    ```python
+    import os
+    from chatlas import ChatMistral
+
+    chat = ChatMistral(api_key=os.getenv("MISTRAL_API_KEY"))
+    chat.chat("Tell me three jokes about statisticians")
+    ```
+
+    Known limitations
+    -----------------
+
+    * Tool calling may be unstable.
+    * Images require a model that supports vision.
+
+    Parameters
+    ----------
+    system_prompt
+        A system prompt to set the behavior of the assistant.
+    model
+        The model to use for the chat. The default, None, will pick a reasonable
+        default, and warn you about it. We strongly recommend explicitly
+        choosing a model for all but the most casual use.
+    api_key
+        The API key to use for authentication. You generally should not supply
+        this directly, but instead set the `MISTRAL_API_KEY` environment
+        variable.
+    base_url
+        The base URL to the endpoint; the default uses Mistral AI.
+    seed
+        Optional integer seed that Mistral uses to try and make output more
+        reproducible.
+    kwargs
+        Additional arguments to pass to the `openai.OpenAI()` client
+        constructor (Mistral uses OpenAI-compatible API).
+
+    Returns
+    -------
+    Chat
+        A chat object that retains the state of the conversation.
+
+    Note
+    ----
+    Pasting an API key into a chat constructor (e.g., `ChatMistral(api_key="...")`)
+    is the simplest way to get started, and is fine for interactive use, but is
+    problematic for code that may be shared with others.
+
+    Instead, consider using environment variables or a configuration file to manage
+    your credentials. One popular way to manage credentials is to use a `.env` file
+    to store your credentials, and then use the `python-dotenv` package to load them
+    into your environment.
+
+    ```shell
+    pip install python-dotenv
+    ```
+
+    ```shell
+    # .env
+    MISTRAL_API_KEY=...
+    ```
+
+    ```python
+    from chatlas import ChatMistral
+    from dotenv import load_dotenv
+
+    load_dotenv()
+    chat = ChatMistral()
+    chat.console()
+    ```
+
+    Another, more general, solution is to load your environment variables into the shell
+    before starting Python (maybe in a `.bashrc`, `.zshrc`, etc. file):
+
+    ```shell
+    export MISTRAL_API_KEY=...
+    ```
+    """
+    if isinstance(seed, MISSING_TYPE):
+        seed = 1014 if is_testing() else None
+
+    if model is None:
+        model = log_model_default("mistral-large-latest")
+
+    if api_key is None:
+        api_key = os.getenv("MISTRAL_API_KEY")
+
+    return Chat(
+        provider=MistralProvider(
+            api_key=api_key,
+            model=model,
+            base_url=base_url,
+            seed=seed,
+            kwargs=kwargs,
+        ),
+        system_prompt=system_prompt,
+    )
+
+
+class MistralProvider(OpenAIProvider):
+    def __init__(
+        self,
+        *,
+        api_key: Optional[str] = None,
+        model: str,
+        base_url: str = "https://api.mistral.ai/v1/",
+        seed: Optional[int] = None,
+        name: str = "Mistral",
+        kwargs: Optional["ChatClientArgs"] = None,
+    ):
+        super().__init__(
+            api_key=api_key,
+            model=model,
+            base_url=base_url,
+            seed=seed,
+            name=name,
+            kwargs=kwargs,
+        )
+
+    # Mistral is essentially OpenAI-compatible, with a couple small differences.
+    # We _could_ bring in the Mistral SDK and use it directly for more precise typing,
+    # etc., but for now that doesn't seem worth it.
+    def _chat_perform_args(
+        self, stream, turns, tools, data_model=None, kwargs=None
+    ) -> "SubmitInputArgs":
+        # Get the base arguments from OpenAI provider
+        kwargs2 = super()._chat_perform_args(stream, turns, tools, data_model, kwargs)
+
+        # Mistral doesn't support stream_options
+        if "stream_options" in kwargs2:
+            del kwargs2["stream_options"]
+
+        # Mistral wants random_seed, not seed
+        if seed := kwargs2.pop("seed", None):
+            if isinstance(seed, int):
+                kwargs2["extra_body"] = {"random_seed": seed}
+            elif seed is not None:
+                raise ValueError(
+                    "MistralProvider only accepts an integer seed, or None."
+                )
+
+        return kwargs2

chatlas/_provider_openai.py

@@ -310,8 +310,7 @@ class OpenAIProvider(
                 del kwargs_full["tools"]
 
         if stream and "stream_options" not in kwargs_full:
-            if self.__class__.__name__ != "DatabricksProvider":
-                kwargs_full["stream_options"] = {"include_usage": True}
+            kwargs_full["stream_options"] = {"include_usage": True}
 
         return kwargs_full
 
@@ -411,7 +410,9 @@ class OpenAIProvider(
                     if isinstance(x, ContentText):
                         content_parts.append({"type": "text", "text": x.text})
                     elif isinstance(x, ContentJson):
-                        content_parts.append({"type": "text", "text": ""})
+                        content_parts.append(
+                            {"type": "text", "text": "<structured data/>"}
+                        )
                     elif isinstance(x, ContentToolRequest):
                         tool_calls.append(
                             {
@@ -450,7 +451,7 @@ class OpenAIProvider(
                     if isinstance(x, ContentText):
                         contents.append({"type": "text", "text": x.text})
                     elif isinstance(x, ContentJson):
-                        contents.append({"type": "text", "text": ""})
+                        contents.append({"type": "text", "text": "<structured data/>"})
                     elif isinstance(x, ContentPDF):
                         contents.append(
                             {
@@ -522,7 +523,10 @@ class OpenAIProvider(
         contents: list[Content] = []
         if message.content is not None:
             if has_data_model:
-                data = orjson.loads(message.content)
+                data = message.content
+                # Some providers (e.g., Cloudflare) may already provide a dict
+                if not isinstance(data, dict):
+                    data = orjson.loads(data)
                 contents = [ContentJson(value=data)]
             else:
                 contents = [ContentText(text=message.content)]

chatlas/_provider_openrouter.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Optional
+
+from ._chat import Chat
+from ._logging import log_model_default
+from ._provider_openai import OpenAIProvider
+from ._utils import MISSING, MISSING_TYPE, is_testing
+
+if TYPE_CHECKING:
+    from ._provider_openai import ChatCompletion
+    from .types.openai import ChatClientArgs, SubmitInputArgs
+
+
+def ChatOpenRouter(
+    *,
+    system_prompt: Optional[str] = None,
+    model: Optional[str] = None,
+    api_key: Optional[str] = None,
+    base_url: str = "https://openrouter.ai/api/v1",
+    seed: Optional[int] | MISSING_TYPE = MISSING,
+    kwargs: Optional["ChatClientArgs"] = None,
+) -> Chat["SubmitInputArgs", ChatCompletion]:
+    """
+    Chat with one of the many models hosted on OpenRouter.
+
+    OpenRouter provides access to a wide variety of language models from different providers
+    through a unified API. Support for features depends on the underlying model that you use.
+
+    Prerequisites
+    -------------
+
+    ::: {.callout-note}
+    ## API key
+
+    Sign up at <https://openrouter.ai> to get an API key.
+    :::
+
+    Examples
+    --------
+
+    ```python
+    import os
+    from chatlas import ChatOpenRouter
+
+    chat = ChatOpenRouter(api_key=os.getenv("OPENROUTER_API_KEY"))
+    chat.chat("What is the capital of France?")
+    ```
+
+    Parameters
+    ----------
+    system_prompt
+        A system prompt to set the behavior of the assistant.
+    model
+        The model to use for the chat. The default, None, will pick a reasonable
+        default, and warn you about it. We strongly recommend explicitly choosing
+        a model for all but the most casual use. See <https://openrouter.ai/models>
+        for available models.
+    api_key
+        The API key to use for authentication. You generally should not supply
+        this directly, but instead set the `OPENROUTER_API_KEY` environment variable.
+    base_url
+        The base URL to the endpoint; the default uses OpenRouter's API.
+    seed
+        Optional integer seed that the model uses to try and make output more
+        reproducible.
+    kwargs
+        Additional arguments to pass to the `openai.OpenAI()` client constructor.
+
+    Returns
+    -------
+    Chat
+        A chat object that retains the state of the conversation.
+
+    Note
+    ----
+    This function is a lightweight wrapper around [](`~chatlas.ChatOpenAI`) with
+    the defaults tweaked for OpenRouter.
+
+    Note
+    ----
+    Pasting an API key into a chat constructor (e.g., `ChatOpenRouter(api_key="...")`)
+    is the simplest way to get started, and is fine for interactive use, but is
+    problematic for code that may be shared with others.
+
+    Instead, consider using environment variables or a configuration file to manage
+    your credentials. One popular way to manage credentials is to use a `.env` file
+    to store your credentials, and then use the `python-dotenv` package to load them
+    into your environment.
+
+    ```shell
+    pip install python-dotenv
+    ```
+
+    ```shell
+    # .env
+    OPENROUTER_API_KEY=...
+    ```
+
+    ```python
+    from chatlas import ChatOpenRouter
+    from dotenv import load_dotenv
+
+    load_dotenv()
+    chat = ChatOpenRouter()
+    chat.console()
+    ```
+
+    Another, more general, solution is to load your environment variables into the shell
+    before starting Python (maybe in a `.bashrc`, `.zshrc`, etc. file):
+
+    ```shell
+    export OPENROUTER_API_KEY=...
+    ```
+    """
+    if model is None:
+        model = log_model_default("gpt-4.1")
+
+    if api_key is None:
+        api_key = os.getenv("OPENROUTER_API_KEY")
+
+    if isinstance(seed, MISSING_TYPE):
+        seed = 1014 if is_testing() else None
+
+    kwargs2 = add_default_headers(kwargs or {})
+
+    return Chat(
+        provider=OpenAIProvider(
+            api_key=api_key,
+            model=model,
+            base_url=base_url,
+            seed=seed,
+            name="OpenRouter",
+            kwargs=kwargs2,
+        ),
+        system_prompt=system_prompt,
+    )
+
+
+def add_default_headers(kwargs: "ChatClientArgs") -> "ChatClientArgs":
+    headers = kwargs.get("default_headers", None)
+    # https://openrouter.ai/docs/api-keys
+    default_headers = {
+        "HTTP-Referer": "https://posit-dev.github.io/chatlas",
+        "X-Title": "chatlas",
+        **(headers or {}),
+    }
+    return {"default_headers": default_headers, **kwargs}

chatlas/_provider_portkey.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING, Optional
+
+from ._chat import Chat
+from ._logging import log_model_default
+from ._provider_openai import OpenAIProvider
+from ._utils import drop_none
+
+if TYPE_CHECKING:
+    from ._provider_openai import ChatCompletion
+    from .types.openai import ChatClientArgs, SubmitInputArgs
+
+
+def ChatPortkey(
+    *,
+    system_prompt: Optional[str] = None,
+    model: Optional[str] = None,
+    api_key: Optional[str] = None,
+    virtual_key: Optional[str] = None,
+    base_url: str = "https://api.portkey.ai/v1",
+    kwargs: Optional["ChatClientArgs"] = None,
+) -> Chat["SubmitInputArgs", ChatCompletion]:
+    """
+    Chat with a model hosted on PortkeyAI
+
+    [PortkeyAI](https://portkey.ai/docs/product/ai-gateway/universal-api)
+    provides an interface (AI Gateway) to connect through its Universal API to a
+    variety of LLMs providers with a single endpoint.
+
+    Prerequisites
+    -------------
+
+    ::: {.callout-note}
+    ## Portkey credentials
+
+    Follow the instructions at <https://portkey.ai/docs/introduction/make-your-first-request>
+    to get started making requests to PortkeyAI. You will need to set the
+    `PORTKEY_API_KEY` environment variable to your Portkey API key, and optionally
+    the `PORTKEY_VIRTUAL_KEY` environment variable to your virtual key.
+    :::
+
+    Examples
+    --------
+    ```python
+    import os
+    from chatlas import ChatPortkey
+
+    chat = ChatPortkey(api_key=os.getenv("PORTKEY_API_KEY"))
+    chat.chat("What is the capital of France?")
+    ```
+
+    Parameters
+    ----------
+    system_prompt
+        A system prompt to set the behavior of the assistant.
+    model
+        The model to use for the chat. The default, None, will pick a reasonable
+        default, and warn you about it. We strongly recommend explicitly
+        choosing a model for all but the most casual use.
+    api_key
+        The API key to use for authentication. You generally should not supply
+        this directly, but instead set the `PORTKEY_API_KEY` environment variable.
+    virtual_key
+        An (optional) virtual identifier, storing the LLM provider's API key. See
+        [documentation](https://portkey.ai/docs/product/ai-gateway/virtual-keys).
+        You generally should not supply this directly, but instead set the
+        `PORTKEY_VIRTUAL_KEY` environment variable.
+    base_url
+        The base URL for the Portkey API. The default is suitable for most users.
+    kwargs
+        Additional arguments to pass to the OpenAIProvider, such as headers or
+        other client configuration options.
+
+    Returns
+    -------
+    Chat
+        A chat object that retains the state of the conversation.
+
+    Notes
+    -----
+    This function is a lightweight wrapper around [](`~chatlas.ChatOpenAI`) with
+    the defaults tweaked for PortkeyAI.
+
+    """
+    if model is None:
+        model = log_model_default("gpt-4.1")
+    if api_key is None:
+        api_key = os.getenv("PORTKEY_API_KEY")
+
+    kwargs2 = add_default_headers(
+        kwargs or {},
+        api_key=api_key,
+        virtual_key=virtual_key,
+    )
+
+    return Chat(
+        provider=OpenAIProvider(
+            api_key=api_key,
+            model=model,
+            base_url=base_url,
+            name="Portkey",
+            kwargs=kwargs2,
+        ),
+        system_prompt=system_prompt,
+    )
+
+
+def add_default_headers(
+    kwargs: "ChatClientArgs",
+    api_key: Optional[str] = None,
+    virtual_key: Optional[str] = None,
+) -> "ChatClientArgs":
+    headers = kwargs.get("default_headers", None)
+    default_headers = drop_none(
+        {
+            "x-portkey-api-key": api_key,
+            "x-portkey-virtual-key": virtual_key,
+            **(headers or {}),
+        }
+    )
+    return {"default_headers": default_headers, **kwargs}

chatlas/_tokens.py

@@ -8,7 +8,7 @@ from typing import TYPE_CHECKING
 import orjson
 
 from ._logging import logger
-from ._typing_extensions import TypedDict
+from ._typing_extensions import NotRequired, TypedDict
 
 if TYPE_CHECKING:
     from ._provider import Provider
@@ -109,11 +109,11 @@ class TokenPrice(TypedDict):
     """The provider name (e.g., "OpenAI", "Anthropic", etc.)"""
     model: str
     """The model name (e.g., "gpt-3.5-turbo", "claude-2", etc.)"""
-    cached_input: float
+    cached_input: NotRequired[float]
     """The cost per user token in USD per million tokens for cached input"""
     input: float
     """The cost per user token in USD per million tokens"""
-    output: float
+    output: NotRequired[float]
     """The cost per assistant token in USD per million tokens"""
 
 
@@ -160,8 +160,8 @@ def compute_cost(
     if price is None:
         return None
     input_price = input_tokens * (price["input"] / 1e6)
-    output_price = output_tokens * (price["output"] / 1e6)
-    cached_price = cached_tokens * (price["cached_input"] / 1e6)
+    output_price = output_tokens * (price.get("output", 0) / 1e6)
+    cached_price = cached_tokens * (price.get("cached_input", 0) / 1e6)
     return input_price + output_price + cached_price
 
 

chatlas/_typing_extensions.py

@@ -14,13 +14,13 @@ else:
 # they should both come from the same typing module.
 # https://peps.python.org/pep-0655/#usage-in-python-3-11
 if sys.version_info >= (3, 11):
-    from typing import Required, TypedDict
+    from typing import NotRequired, Required, TypedDict
 else:
-    from typing_extensions import Required, TypedDict
+    from typing_extensions import NotRequired, Required, TypedDict
 
 
 # The only purpose of the following line is so that pyright will put all of the
 # conditional imports into the .pyi file when generating type stubs. Without this line,
 # pyright will not include the above imports in the generated .pyi file, and it will
 # result in a lot of red squiggles in user code.
-_: "ParamSpec | TypeGuard | is_typeddict | Required | TypedDict"  # type: ignore
+_: "ParamSpec | TypeGuard | is_typeddict | NotRequired | Required | TypedDict"  # type: ignore

chatlas/_version.py

@@ -1,7 +1,14 @@
 # file generated by setuptools-scm
 # don't change, don't track in version control
 
-__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
 
 TYPE_CHECKING = False
 if TYPE_CHECKING:
@@ -9,13 +16,19 @@ if TYPE_CHECKING:
     from typing import Union
 
     VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
 else:
     VERSION_TUPLE = object
+    COMMIT_ID = object
 
 version: str
 __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
 
-__version__ = version = '0.9.2'
-__version_tuple__ = version_tuple = (0, 9, 2)
+__version__ = version = '0.10.0'
+__version_tuple__ = version_tuple = (0, 10, 0)
+
+__commit_id__ = commit_id = None

chatlas/types/anthropic/_client.py

@@ -17,5 +17,5 @@ class ChatClientArgs(TypedDict, total=False):
     max_retries: int
     default_headers: Optional[Mapping[str, str]]
     default_query: Optional[Mapping[str, object]]
-    http_client: httpx.AsyncClient
+    http_client: httpx.AsyncClient | None
     _strict_response_validation: bool

chatlas/types/anthropic/_client_bedrock.py

@@ -19,5 +19,5 @@ class ChatBedrockClientArgs(TypedDict, total=False):
     max_retries: int
     default_headers: Optional[Mapping[str, str]]
     default_query: Optional[Mapping[str, object]]
-    http_client: httpx.AsyncClient
+    http_client: httpx.AsyncClient | None
     _strict_response_validation: bool

chatlas/types/openai/_client.py

@@ -20,5 +20,5 @@ class ChatClientArgs(TypedDict, total=False):
     max_retries: int
     default_headers: Optional[Mapping[str, str]]
     default_query: Optional[Mapping[str, object]]
-    http_client: httpx.AsyncClient
+    http_client: httpx.AsyncClient | None
     _strict_response_validation: bool

chatlas/types/openai/_client_azure.py

@@ -23,5 +23,5 @@ class ChatAzureClientArgs(TypedDict, total=False):
     max_retries: int
     default_headers: Optional[Mapping[str, str]]
     default_query: Optional[Mapping[str, object]]
-    http_client: httpx.AsyncClient
+    http_client: httpx.AsyncClient | None
     _strict_response_validation: bool

chatlas/types/openai/_submit.py

@@ -177,6 +177,9 @@ class SubmitInputArgs(TypedDict, total=False):
     top_p: Union[float, None, openai.NotGiven]
     user: str | openai.NotGiven
     verbosity: Union[Literal["low", "medium", "high"], None, openai.NotGiven]
+    web_search_options: (
+        openai.types.chat.completion_create_params.WebSearchOptions | openai.NotGiven
+    )
     extra_headers: Optional[Mapping[str, Union[str, openai.Omit]]]
     extra_query: Optional[Mapping[str, object]]
     extra_body: object | None

{chatlas-0.9.2.dist-info → chatlas-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatlas
-Version: 0.9.2
+Version: 0.10.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
@@ -79,7 +79,7 @@ Provides-Extra: vertex
 Requires-Dist: google-genai>=1.14.0; extra == 'vertex'
 Description-Content-Type: text/markdown
 
-# chatlas <a href="https://posit-dev.github.io/chatlas"><img src="docs/logos/hex/logo.png" align="right" height="138" alt="chatlas website" /></a>
+# chatlas <a href="https://posit-dev.github.io/chatlas"><img src="https://posit-dev.github.io/chatlas/logos/hex/logo.png" align="right" height="138" alt="chatlas website" /></a>
 
 <p>
 <!-- badges start -->
@@ -135,7 +135,7 @@ chat.chat("How's the weather in San Francisco?")
 ```
 
 
-<img src="docs/images/chatlas-hello.png" alt="Model response output to the user query: 'How's the weather in San Francisco?'" width="67%" style="display: block; margin-left: auto; margin-right: auto">
+<img src="https://posit-dev.github.io/chatlas/images/chatlas-hello.png" alt="Model response output to the user query: 'How's the weather in San Francisco?'" width="67%" style="display: block; margin-left: auto; margin-right: auto">
 
 
 Learn more at <https://posit-dev.github.io/chatlas>

{chatlas-0.9.2.dist-info → chatlas-0.10.0.dist-info}/RECORD

@@ -1,7 +1,7 @@
-chatlas/__init__.py,sha256=AynwP-KZLrA_U4aYUt7JgnRZKydodszWPu-tnmeh6xc,1706
+chatlas/__init__.py,sha256=acbfWs7cquCWnP3ZyxYNNQLSQyIvEg2jbDn2O0iArnE,2111
 chatlas/_auto.py,sha256=-s7XGzsKLX4RipWtk4WOE8iKbOBhXPUPtI0-63PpXCY,5660
 chatlas/_callbacks.py,sha256=3RpPaOQonTqScjXbaShgKJ1Rc-YxzWerxKRBjVssFnc,1838
-chatlas/_chat.py,sha256=RA0EZIbMC6fEulzYIJdE9QMmFMRgF4zkenoXwAtwpTs,82048
+chatlas/_chat.py,sha256=cZ7HG4jELhRumNvbSvsG0Lv-GZTl9wQrx8oydnAmKxE,82062
 chatlas/_content.py,sha256=Jk0frLSdZTEyGu4KDHsgQbQQDHEX9nYVMNUXx4OKGSo,19775
 chatlas/_content_image.py,sha256=EUK6wAint-JatLsiwvaPDu4D3W-NcIsDCkzABkXgfDg,8304
 chatlas/_content_pdf.py,sha256=cffeuJxzhUDukQ-Srkmpy62M8X12skYpU_FVq-Wvya4,2420
@@ -12,37 +12,43 @@ chatlas/_logging.py,sha256=weKvXZDIZ88X7X61ruXM_S0AAhQ5mgiW9dR-km8x7Mg,3324
 chatlas/_mcp_manager.py,sha256=smMXeKZzP90MrlCdnTHMyo7AWHwl7J2jkU8dKSlnEsQ,10237
 chatlas/_merge.py,sha256=SGj_BetgA7gaOqSBKOhYmW3CYeQKTEehFrXvx3y4OYE,3924
 chatlas/_provider.py,sha256=0cl6JtMe6xRbc-ghp4JqdwTv6OQeewQUgdToRSktJ3I,5374
-chatlas/_provider_anthropic.py,sha256=5pcV0_eUHnQVVLSUfJiZ18Udf9vmbxDoPzcpFJJhicE,26005
-chatlas/_provider_databricks.py,sha256=RAaWJTNOj0qmmOBg6Lg59idKE6ekm4JDsHgL2Pwq6Xc,4162
+chatlas/_provider_anthropic.py,sha256=YHXZLtrNnZEVPGYGgsfsiqpM9Zm6HDv8zuj3cW7i8FE,25888
+chatlas/_provider_cloudflare.py,sha256=Q3YB0wMl_DWWBCp7RmDMXxDqIScM1mSKeNTEJ5xpIOY,4932
+chatlas/_provider_databricks.py,sha256=XytRyn_oAJzSUfz4CkTqq2LsCyYror4VN5jBO55tx0E,4526
+chatlas/_provider_deepseek.py,sha256=6nPtPSo-Po6sD4i8PZJHuI5T2oATpLi5djXFGdlserk,4906
 chatlas/_provider_github.py,sha256=68dXdNxEQo5Yf7MtxA-SdV3HGXzMEQie1sP3c5u7Akk,3921
 chatlas/_provider_google.py,sha256=Q-VgKij7T3y3zPMhx73BxoHM8RG499Ediw4lMNWWVYA,20297
 chatlas/_provider_groq.py,sha256=XB2JDyuF95CcSbNkgk7JHcuy9KCW7hxTVaONDSjK8U8,3671
+chatlas/_provider_huggingface.py,sha256=feJ416X0UdtyoeHZbkgolFf62D7zxNwM7i_X3NYsQQw,4669
+chatlas/_provider_mistral.py,sha256=-p4rut0KCn-PrwnOlvr6lK8-K-OXvc5H9vTX-rCzUkk,5309
 chatlas/_provider_ollama.py,sha256=2TNg5UTEYQvjeChqyJ8hh8fV-A0Xh-B5Hv8b5rtA9FY,3309
-chatlas/_provider_openai.py,sha256=MGvlRlItaqzqRaqZ6Nenf3N1NUbH-MwaSltOTk6phms,25374
+chatlas/_provider_openai.py,sha256=wupHVATX3Ra244jRLhQkAitBZzp0MIIuCYIzdYiPdEU,25554
+chatlas/_provider_openrouter.py,sha256=9sCXvROVIiUdwfEbkVA-15_kc6ouFUP2uV2MmUe2rFk,4385
 chatlas/_provider_perplexity.py,sha256=hEfKYmNrv3yU-IP_3xCS02u7pQunhKC6iZpoiKWX9fc,3958
+chatlas/_provider_portkey.py,sha256=G-U66By6t5iW4h5m4ut_2DBUq8Z7qTtcjuty-WF3nSw,3809
 chatlas/_provider_snowflake.py,sha256=83P7NiNT3D_JNeX_zs4JXwDWeoaYo9IKxN91W0GWWho,24310
-chatlas/_tokens.py,sha256=Z004y1dGoRVV36BfRnOfeUhUJgwh94QhNRWwE5867Bo,5335
+chatlas/_tokens.py,sha256=QUsBLNJPgXk8vovcG5JdQU8NarCv7FRpOVBdgFkBgHs,5388
 chatlas/_tokens_old.py,sha256=L9d9oafrXvEx2u4nIn_Jjn7adnQyLBnYBuPwJUE8Pl8,5005
 chatlas/_tools.py,sha256=bOXJ0ry6vQqU8Qm-PVdESN8HTuUv1teqPH_vtqILv9k,11088
 chatlas/_turn.py,sha256=yK7alUxeP8d2iBc7amyz20BtEqcpvX6BCwWZsnlQ5R4,4515
-chatlas/_typing_extensions.py,sha256=YdzmlyPSBpIEcsOkoz12e6jETT1XEMV2Q72haE4cfwY,1036
+chatlas/_typing_extensions.py,sha256=MB9vWMWlm-IF8uOQfrTcfb66MV6gYXn3zgnbdwAC7BQ,1076
 chatlas/_utils.py,sha256=Kku2fa1mvTYCr5D28VxE6-fwfy2e2doCi-eKQkLEg4Y,4686
-chatlas/_version.py,sha256=eeYYTSIkrgfRwSQ7LKo_py3xs3DvzgfWiAtK4K1JM4A,511
+chatlas/_version.py,sha256=XS8OMho0YiZyQ_qDeRsy__m_nWUzYVEJw-NLk1VtDQU,706
 chatlas/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chatlas/data/prices.json,sha256=vESC5G1SDCnPrfRQTrvJ9wVdxyLEJZrAygV0oJ99ccc,56230
 chatlas/types/__init__.py,sha256=oRgbo1FIC2qkiZ6Bi4n3RNgCA6VDTeueoCHO4-6h1NA,725
 chatlas/types/anthropic/__init__.py,sha256=OwubA-DPHYpYo0XyRyAFwftOI0mOxtHzAyhUSLcDx54,417
-chatlas/types/anthropic/_client.py,sha256=G0LRhoFBcsSOMr5qhP-0rAScsVXaVlHCpggfVp54bnQ,690
-chatlas/types/anthropic/_client_bedrock.py,sha256=mNazQlu0pQt8JdzrYn3LKNgE4n732GjhQUJdQQK9QkY,785
+chatlas/types/anthropic/_client.py,sha256=t_tnOzzsW1xWNADkNoAuZJYoE9QJ8ie7DQNnFO1pvoM,697
+chatlas/types/anthropic/_client_bedrock.py,sha256=2J6U1QcSx1KwiiHfXs3i4YEXDXw11sp-x3iLOuESrgQ,792
 chatlas/types/anthropic/_submit.py,sha256=o5bpKEne6lqBz4YBLoYwRLKCVmBIdzRetiMCoOdUfb0,3661
 chatlas/types/google/__init__.py,sha256=ZJhi8Kwvio2zp8T1TQqmvdHqkS-Khb6BGESPjREADgo,337
 chatlas/types/google/_client.py,sha256=t7aKbxYq_xOA1Z3RnWcjewifdQFSHi7vKEj6MyKMCJk,729
 chatlas/types/google/_submit.py,sha256=19Ji4fAo1lTCbNSpR6Yi0i64RJwMGBdiZKQcnoDNRwY,1796
 chatlas/types/openai/__init__.py,sha256=Q2RAr1bSH1nHsxICK05nAmKmxdhKmhbBkWD_XHiVSrI,411
-chatlas/types/openai/_client.py,sha256=xEnMiVFjeIQkfMtTWA4mZP_cQbh8uBphml0H7x4ot4Q,785
-chatlas/types/openai/_client_azure.py,sha256=Dw8AgWgBgjSOkpYKAyjlx8Gxndc2E4FLww32FzqTRPg,889
-chatlas/types/openai/_submit.py,sha256=kZ7pAXUW5sUzY5-q4GLYOQigOxL4kAuRup-3nJM7NDg,7697
-chatlas-0.9.2.dist-info/METADATA,sha256=W7hyhJ18k9R1Q1vw-vB659_Cb7FLUVTZM7F3x_3j-v8,5531
-chatlas-0.9.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-chatlas-0.9.2.dist-info/licenses/LICENSE,sha256=zyuGzPOC7CcbOaBHsQ3UEyKYRO56KDUkor0OA4LqqDg,1081
-chatlas-0.9.2.dist-info/RECORD,,
+chatlas/types/openai/_client.py,sha256=SttisELwAd52_Je_5q3RfWGdX5wbg2CoGbxhS8ThS0A,792
+chatlas/types/openai/_client_azure.py,sha256=b8Hr7iKYA5-sq9r7uEqbBFv9yo3itppmHIgkEGvChMs,896
+chatlas/types/openai/_submit.py,sha256=rhft1h7zy6eSlSBLkt7ZAySFh-8WnR5UEG-BXaFTxag,7815
+chatlas-0.10.0.dist-info/METADATA,sha256=dhX_Mf6xlpwwaJajsGTGuJ7GCwEZLmBZqqU7NvbOObY,5594
+chatlas-0.10.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+chatlas-0.10.0.dist-info/licenses/LICENSE,sha256=zyuGzPOC7CcbOaBHsQ3UEyKYRO56KDUkor0OA4LqqDg,1081
+chatlas-0.10.0.dist-info/RECORD,,