chatlas 0.11.0__py3-none-any.whl → 0.12.0__py3-none-any.whl

chatlas/_auto.py

@@ -1,32 +1,46 @@
 from __future__ import annotations
 
 import os
+import warnings
 from typing import Callable, Literal, Optional
 
 import orjson
 
 from ._chat import Chat
 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 ._utils import MISSING_TYPE as DEPRECATED_TYPE
 
 AutoProviders = Literal[
     "anthropic",
     "bedrock-anthropic",
+    "cloudflare",
     "databricks",
+    "deep-seek",
     "github",
     "google",
     "groq",
+    "hugging-face",
+    "mistral",
     "ollama",
     "openai",
     "azure-openai",
+    "open-router",
     "perplexity",
+    "portkey",
     "snowflake",
     "vertex",
 ]
@@ -34,41 +48,40 @@ AutoProviders = Literal[
 _provider_chat_model_map: dict[AutoProviders, Callable[..., Chat]] = {
     "anthropic": ChatAnthropic,
     "bedrock-anthropic": ChatBedrockAnthropic,
+    "cloudflare": ChatCloudflare,
     "databricks": ChatDatabricks,
+    "deep-seek": ChatDeepSeek,
     "github": ChatGithub,
     "google": ChatGoogle,
     "groq": ChatGroq,
+    "hugging-face": ChatHuggingFace,
+    "mistral": ChatMistral,
     "ollama": ChatOllama,
     "openai": ChatOpenAI,
     "azure-openai": ChatAzureOpenAI,
+    "open-router": ChatOpenRouter,
     "perplexity": ChatPerplexity,
+    "portkey": ChatPortkey,
     "snowflake": ChatSnowflake,
     "vertex": ChatVertex,
 }
 
+DEPRECATED = DEPRECATED_TYPE()
+
 
 def ChatAuto(
-    system_prompt: Optional[str] = None,
+    provider_model: Optional[str] = None,
     *,
-    provider: Optional[AutoProviders] = None,
-    model: Optional[str] = None,
+    system_prompt: Optional[str] = None,
+    provider: AutoProviders | DEPRECATED_TYPE = DEPRECATED,
+    model: str | DEPRECATED_TYPE = DEPRECATED,
     **kwargs,
 ) -> Chat:
     """
-    Use environment variables (env vars) to configure the Chat provider and model.
+    Chat with any provider.
 
-    Creates a :class:`~chatlas.Chat` instance based on the specified provider.
-    The provider may be specified through the `provider` parameter and/or the
-    `CHATLAS_CHAT_PROVIDER` env var. If both are set, the env var takes
-    precedence. Similarly, the provider's model may be specified through the
-    `model` parameter and/or the `CHATLAS_CHAT_MODEL` env var. Also, additional
-    configuration may be provided through the `kwargs` parameter and/or the
-    `CHATLAS_CHAT_ARGS` env var (as a JSON string). In this case, when both are
-    set, they are merged, with the env var arguments taking precedence.
-
-    As a result, `ChatAuto()` provides a convenient way to set a default
-    provider and model in your Python code, while allowing you to override
-    these settings through env vars (i.e., without modifying your code).
+    This is a generic interface to all the other `Chat*()` functions, allowing
+    you to pick the provider (and model) with a simple string.
 
     Prerequisites
     -------------
@@ -86,55 +99,101 @@ def ChatAuto(
     Python packages.
     :::
 
-
     Examples
     --------
-    First, set the environment variables for the provider, arguments, and API key:
 
-    ```bash
-    export CHATLAS_CHAT_PROVIDER=anthropic
-    export CHATLAS_CHAT_MODEL=claude-3-haiku-20240229
-    export CHATLAS_CHAT_ARGS='{"kwargs": {"max_retries": 3}}'
-    export ANTHROPIC_API_KEY=your_api_key
+    `ChatAuto()` makes it easy to switch between different chat providers and models.
+
+    ```python
+    import pandas as pd
+    from chatlas import ChatAuto
+
+    # Default provider (OpenAI) & model
+    chat = ChatAuto()
+    print(chat.provider.name)
+    print(chat.provider.model)
+
+    # Different provider (Anthropic) & default model
+    chat = ChatAuto("anthropic")
+
+    # List models available through the provider
+    models = chat.list_models()
+    print(pd.DataFrame(models))
+
+    # Choose specific provider/model (Claude Sonnet 4)
+    chat = ChatAuto("anthropic/claude-sonnet-4-0")
     ```
 
-    Then, you can use the `ChatAuto` function to create a Chat instance:
+    The default provider/model can also be controlled through an environment variable:
+
+    ```bash
+    export CHATLAS_CHAT_PROVIDER_MODEL="anthropic/claude-sonnet-4-0"
+    ```
 
     ```python
     from chatlas import ChatAuto
 
     chat = ChatAuto()
-    chat.chat("What is the capital of France?")
+    print(chat.provider.name)   # anthropic
+    print(chat.provider.model)  # claude-sonnet-4-0
+    ```
+
+    For application-specific configurations, consider defining your own environment variables:
+
+    ```bash
+    export MYAPP_PROVIDER_MODEL="google/gemini-2.5-flash"
+    ```
+
+    And passing them to `ChatAuto()` as an alternative way to configure the provider/model:
+
+    ```python
+    import os
+    from chatlas import ChatAuto
+
+    chat = ChatAuto(os.getenv("MYAPP_PROVIDER_MODEL"))
+    print(chat.provider.name)   # google
+    print(chat.provider.model)  # gemini-2.5-flash
     ```
 
     Parameters
     ----------
+    provider_model
+        The name of the provider and model to use in the format
+        `"{provider}/{model}"`. Providers are strings formatted in kebab-case,
+        e.g. to use `ChatBedrockAnthropic` set `provider="bedrock-anthropic"`,
+        and models are the provider-specific model names, e.g.
+        `"claude-3-7-sonnet-20250219"`. The `/{model}` portion may also be
+        omitted, in which case, the default model for that provider will be
+        used.
+
+        If no value is provided, the `CHATLAS_CHAT_PROVIDER_MODEL` environment
+        variable will be consulted for a fallback value. If this variable is also
+        not set, a default value of `"openai"` is used.
     system_prompt
         A system prompt to set the behavior of the assistant.
     provider
-        The name of the default chat provider to use. Providers are strings
-        formatted in kebab-case, e.g. to use `ChatBedrockAnthropic` set
-        `provider="bedrock-anthropic"`.
-
-        This value can also be provided via the `CHATLAS_CHAT_PROVIDER`
-        environment variable, which takes precedence over `provider`
-        when set.
+        Deprecated; use `provider_model` instead.
     model
-        The name of the default model to use. This value can also be provided
-        via the `CHATLAS_CHAT_MODEL` environment variable, which takes
-        precedence over `model` when set.
+        Deprecated; use `provider_model` instead.
     **kwargs
-        Additional keyword arguments to pass to the Chat constructor. See the
+        Additional keyword arguments to pass to the `Chat` constructor. See the
         documentation for each provider for more details on the available
         options.
 
         These arguments can also be provided via the `CHATLAS_CHAT_ARGS`
-        environment variable as a JSON string. When provided, the options
-        in the `CHATLAS_CHAT_ARGS` envvar take precedence over the options
-        passed to `kwargs`.
+        environment variable as a JSON string. When any additional arguments are
+        provided to `ChatAuto()`, the env var is ignored.
+
+        Note that `system_prompt` and `turns` can't be set via environment variables.
+        They must be provided/set directly to/on `ChatAuto()`.
 
-        Note that `system_prompt` and `turns` in `kwargs` or in
-        `CHATLAS_CHAT_ARGS` are ignored.
+    Note
+    ----
+    If you want to work with a specific provider, but don't know what models are
+    available (or the exact model name), use
+    `ChatAuto('provider_name').list_models()` to list available models. Another
+    option is to use the provider more directly (e.g., `ChatAnthropic()`). There,
+    the `model` parameter may have type hints for available models.
 
     Returns
     -------
@@ -147,32 +206,85 @@ def ChatAuto(
         If no valid provider is specified either through parameters or
         environment variables.
     """
-    the_provider = os.environ.get("CHATLAS_CHAT_PROVIDER", provider)
+    if provider is not DEPRECATED:
+        warn_deprecated_param("provider")
+
+    if model is not DEPRECATED:
+        if provider is DEPRECATED:
+            raise ValueError(
+                "The `model` parameter is deprecated and cannot be used without the `provider` parameter. "
+                "Use `provider_model` instead."
+            )
+        warn_deprecated_param("model")
+
+    if provider_model is None:
+        provider_model = os.environ.get("CHATLAS_CHAT_PROVIDER_MODEL")
+
+    # Backwards compatibility: construct from old env vars as a fallback
+    if provider_model is None:
+        env_provider = get_legacy_env_var("CHATLAS_CHAT_PROVIDER", provider)
+        env_model = get_legacy_env_var("CHATLAS_CHAT_MODEL", model)
+
+        if env_provider:
+            provider_model = env_provider
+            if env_model:
+                provider_model += f"/{env_model}"
+
+    # Fall back to OpenAI if nothing is specified
+    if provider_model is None:
+        provider_model = "openai"
+
+    if "/" in provider_model:
+        the_provider, the_model = provider_model.split("/", 1)
+    else:
+        the_provider, the_model = provider_model, None
 
-    if the_provider is None:
-        raise ValueError(
-            "Provider name is required as parameter or `CHATLAS_CHAT_PROVIDER` must be set."
-        )
     if the_provider not in _provider_chat_model_map:
         raise ValueError(
             f"Provider name '{the_provider}' is not a known chatlas provider: "
             f"{', '.join(_provider_chat_model_map.keys())}"
         )
 
-    # `system_prompt` and `turns` always come from `ChatAuto()`
-    base_args = {"system_prompt": system_prompt}
-
-    if env_model := os.environ.get("CHATLAS_CHAT_MODEL"):
-        model = env_model
-
-    if model:
-        base_args["model"] = model
+    # `system_prompt`, `turns` and `model` always come from `ChatAuto()`
+    base_args = {
+        "system_prompt": system_prompt,
+        "turns": None,
+        "model": the_model,
+    }
 
+    # Environment kwargs, used only if no kwargs provided
     env_kwargs = {}
-    if env_kwargs_str := os.environ.get("CHATLAS_CHAT_ARGS"):
-        env_kwargs = orjson.loads(env_kwargs_str)
-
-    kwargs = {**kwargs, **env_kwargs, **base_args}
-    kwargs = {k: v for k, v in kwargs.items() if v is not None}
-
-    return _provider_chat_model_map[the_provider](**kwargs)
+    if not kwargs:
+        env_kwargs = orjson.loads(os.environ.get("CHATLAS_CHAT_ARGS", "{}"))
+
+    final_kwargs = {**env_kwargs, **kwargs, **base_args}
+    final_kwargs = {k: v for k, v in final_kwargs.items() if v is not None}
+
+    return _provider_chat_model_map[the_provider](**final_kwargs)
+
+
+def get_legacy_env_var(
+    env_var_name: str,
+    default: str | DEPRECATED_TYPE,
+) -> str | None:
+    env_value = os.environ.get(env_var_name)
+    if env_value:
+        warnings.warn(
+            f"The '{env_var_name}' environment variable is deprecated. "
+            "Use 'CHATLAS_CHAT_PROVIDER_MODEL' instead.",
+            DeprecationWarning,
+            stacklevel=3,
+        )
+        return env_value
+    elif isinstance(default, DEPRECATED_TYPE):
+        return None
+    else:
+        return default
+
+
+def warn_deprecated_param(param_name: str, stacklevel: int = 3) -> None:
+    warnings.warn(
+        f"The '{param_name}' parameter is deprecated. Use 'provider_model' instead.",
+        DeprecationWarning,
+        stacklevel=stacklevel,
+    )

chatlas/_chat.py

@@ -34,6 +34,7 @@ from ._content import (
     ContentText,
     ContentToolRequest,
     ContentToolResult,
+    ToolInfo,
 )
 from ._display import (
     EchoDisplayOptions,
@@ -52,7 +53,7 @@ from ._typing_extensions import TypedDict, TypeGuard
 from ._utils import MISSING, MISSING_TYPE, html_escape, wrap_async
 
 if TYPE_CHECKING:
-    from mcp.types import ToolAnnotations
+    from ._content import ToolAnnotations
 
 
 class TokensDict(TypedDict):
@@ -1534,9 +1535,10 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
 
     def register_tool(
         self,
-        func: Callable[..., Any] | Callable[..., Awaitable[Any]],
+        func: Callable[..., Any] | Callable[..., Awaitable[Any]] | Tool,
         *,
         force: bool = False,
+        name: Optional[str] = None,
         model: Optional[type[BaseModel]] = None,
         annotations: "Optional[ToolAnnotations]" = None,
     ):
@@ -1610,6 +1612,9 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         force
             If `True`, overwrite any existing tool with the same name. If `False`
             (the default), raise an error if a tool with the same name already exists.
+        name
+            The name of the tool. If not provided, the name will be inferred from the
+            `func`'s name (or the `model`'s name, if provided).
         model
             A Pydantic model that describes the input parameters for the function.
             If not provided, the model will be inferred from the function's type hints.
@@ -1618,14 +1623,22 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             name and docstring of the function.
         annotations
             Additional properties that describe the tool and its behavior.
-            Should be a `from mcp.types import ToolAnnotations` instance.
 
         Raises
         ------
         ValueError
             If a tool with the same name already exists and `force` is `False`.
         """
-        tool = Tool.from_func(func, model=model, annotations=annotations)
+        if isinstance(func, Tool):
+            name = name or func.name
+            annotations = annotations or func.annotations
+            if model is not None:
+                func = Tool.from_func(
+                    func.func, name=name, model=model, annotations=annotations
+                )
+            func = func.func
+
+        tool = Tool.from_func(func, name=name, model=model, annotations=annotations)
         if tool.name in self._tools and not force:
             raise ValueError(
                 f"Tool with name '{tool.name}' is already registered. "
@@ -1933,7 +1946,9 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             all_results: list[ContentToolResult] = []
             for x in turn.contents:
                 if isinstance(x, ContentToolRequest):
-                    x.tool = self._tools.get(x.name)
+                    tool = self._tools.get(x.name)
+                    if tool is not None:
+                        x.tool = ToolInfo.from_tool(tool)
                     if echo == "output":
                         self._echo_content(f"\n\n{x}\n\n")
                     if content == "all":
@@ -1994,7 +2009,9 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             all_results: list[ContentToolResult] = []
             for x in turn.contents:
                 if isinstance(x, ContentToolRequest):
-                    x.tool = self._tools.get(x.name)
+                    tool = self._tools.get(x.name)
+                    if tool is not None:
+                        x.tool = ToolInfo.from_tool(tool)
                     if echo == "output":
                         self._echo_content(f"\n\n{x}\n\n")
                     if content == "all":
@@ -2152,7 +2169,7 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         self._turns.extend([user_turn, turn])
 
     def _invoke_tool(self, request: ContentToolRequest):
-        tool = request.tool
+        tool = self._tools.get(request.name)
         func = tool.func if tool is not None else None
 
         if func is None:
@@ -2200,7 +2217,7 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             yield self._handle_tool_error_result(request, e)
 
     async def _invoke_tool_async(self, request: ContentToolRequest):
-        tool = request.tool
+        tool = self._tools.get(request.name)
 
         if tool is None:
             yield self._handle_tool_error_result(

chatlas/_content.py

@@ -6,9 +6,64 @@ from typing import TYPE_CHECKING, Any, Literal, Optional, Union
 import orjson
 from pydantic import BaseModel, ConfigDict
 
+from ._typing_extensions import TypedDict
+
 if TYPE_CHECKING:
     from ._tools import Tool
 
+
+class ToolAnnotations(TypedDict, total=False):
+    """
+    Additional properties describing a Tool to clients.
+
+    NOTE: all properties in ToolAnnotations are **hints**.
+    They are not guaranteed to provide a faithful description of
+    tool behavior (including descriptive properties like `title`).
+
+    Clients should never make tool use decisions based on ToolAnnotations
+    received from untrusted servers.
+    """
+
+    title: str
+    """A human-readable title for the tool."""
+
+    readOnlyHint: bool
+    """
+    If true, the tool does not modify its environment.
+    Default: false
+    """
+
+    destructiveHint: bool
+    """
+    If true, the tool may perform destructive updates to its environment.
+    If false, the tool performs only additive updates.
+    (This property is meaningful only when `readOnlyHint == false`)
+    Default: true
+    """
+
+    idempotentHint: bool
+    """
+    If true, calling the tool repeatedly with the same arguments
+    will have no additional effect on the its environment.
+    (This property is meaningful only when `readOnlyHint == false`)
+    Default: false
+    """
+
+    openWorldHint: bool
+    """
+    If true, this tool may interact with an "open world" of external
+    entities. If false, the tool's domain of interaction is closed.
+    For example, the world of a web search tool is open, whereas that
+    of a memory tool is not.
+    Default: true
+    """
+
+    extra: dict[str, Any]
+    """
+    Additional metadata about the tool.
+    """
+
+
 ImageContentTypes = Literal[
     "image/png",
     "image/jpeg",
@@ -19,6 +74,45 @@ ImageContentTypes = Literal[
 Allowable content types for images.
 """
 
+
+class ToolInfo(BaseModel):
+    """
+    Serializable tool information
+
+    This contains only the serializable parts of a Tool that are needed
+    for ContentToolRequest to be JSON-serializable. This allows tool
+    metadata to be preserved without including the non-serializable
+    function reference.
+
+    Parameters
+    ----------
+    name
+        The name of the tool.
+    description
+        A description of what the tool does.
+    parameters
+        A dictionary describing the input parameters and their types.
+    annotations
+        Additional properties that describe the tool and its behavior.
+    """
+
+    name: str
+    description: str
+    parameters: dict[str, Any]
+    annotations: Optional[ToolAnnotations] = None
+
+    @classmethod
+    def from_tool(cls, tool: "Tool") -> "ToolInfo":
+        """Create a ToolInfo from a Tool instance."""
+        func_schema = tool.schema["function"]
+        return cls(
+            name=tool.name,
+            description=func_schema.get("description", ""),
+            parameters=func_schema.get("parameters", {}),
+            annotations=tool.annotations,
+        )
+
+
 ContentTypeEnum = Literal[
     "text",
     "image_remote",
@@ -175,14 +269,15 @@ class ContentToolRequest(Content):
     arguments
         The arguments to pass to the tool/function.
     tool
-        The tool/function to be called. This is set internally by chatlas's tool
-        calling loop.
+        Serializable information about the tool. This is set internally by
+        chatlas's tool calling loop and contains only the metadata needed
+        for serialization (name, description, parameters, annotations).
     """
 
     id: str
     name: str
     arguments: object
-    tool: Optional["Tool"] = None
+    tool: Optional[ToolInfo] = None
 
     content_type: ContentTypeEnum = "tool_request"
 

chatlas/_tools.py

@@ -2,7 +2,15 @@ from __future__ import annotations
 
 import inspect
 import warnings
-from typing import TYPE_CHECKING, Any, AsyncGenerator, Awaitable, Callable, Optional
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    AsyncGenerator,
+    Awaitable,
+    Callable,
+    Optional,
+    cast,
+)
 
 import openai
 from pydantic import BaseModel, Field, create_model
@@ -12,6 +20,7 @@ from ._content import (
     ContentToolResult,
     ContentToolResultImage,
     ContentToolResultResource,
+    ToolAnnotations,
 )
 
 __all__ = (
@@ -22,7 +31,6 @@ __all__ = (
 if TYPE_CHECKING:
     from mcp import ClientSession as MCPClientSession
     from mcp import Tool as MCPTool
-    from mcp.types import ToolAnnotations
     from openai.types.chat import ChatCompletionToolParam
 
 
@@ -44,8 +52,7 @@ class Tool:
     parameters
         A dictionary describing the input parameters and their types.
     annotations
-        Additional properties that describe the tool and its behavior. Should be
-        a `from mcp.types import ToolAnnotations` instance.
+        Additional properties that describe the tool and its behavior.
     """
 
     func: Callable[..., Any] | Callable[..., Awaitable[Any]]
@@ -77,6 +84,7 @@ class Tool:
         cls: type["Tool"],
         func: Callable[..., Any] | Callable[..., Awaitable[Any]],
         *,
+        name: Optional[str] = None,
         model: Optional[type[BaseModel]] = None,
         annotations: "Optional[ToolAnnotations]" = None,
     ) -> "Tool":
@@ -87,6 +95,9 @@ class Tool:
         ----------
         func
             The function to wrap as a tool.
+        name
+            The name of the tool. If not provided, the name will be inferred from the
+            function's name.
         model
             A Pydantic model that describes the input parameters for the function.
             If not provided, the model will be inferred from the function's type hints.
@@ -94,8 +105,7 @@ class Tool:
             Note that the name and docstring of the model takes precedence over the
             name and docstring of the function.
         annotations
-            Additional properties that describe the tool and its behavior. Should be
-            a `from mcp.types import ToolAnnotations` instance.
+            Additional properties that describe the tool and its behavior.
 
         Returns
         -------
@@ -114,7 +124,8 @@ class Tool:
         # Throw if there is a mismatch between the model and the function parameters
         params = inspect.signature(func).parameters
         fields = model.model_fields
-        diff = set(params) ^ set(fields)
+        fields_alias = [val.alias if val.alias else key for key, val in fields.items()]
+        diff = set(params) ^ set(fields_alias)
         if diff:
             raise ValueError(
                 f"`model` fields must match tool function parameters exactly. "
@@ -125,7 +136,7 @@ class Tool:
 
         return cls(
             func=func,
-            name=model.__name__ or func.__name__,
+            name=name or model.__name__ or func.__name__,
             description=model.__doc__ or func.__doc__ or "",
             parameters=params,
             annotations=annotations,
@@ -203,12 +214,17 @@ class Tool:
 
         params = mcp_tool_input_schema_to_param_schema(mcp_tool.inputSchema)
 
+        # Convert MCP ToolAnnotations to our TypedDict format
+        annotations = None
+        if mcp_tool.annotations:
+            annotations = cast(ToolAnnotations, mcp_tool.annotations.model_dump())
+
         return cls(
             func=_utils.wrap_async(_call),
             name=mcp_tool.name,
             description=mcp_tool.description or "",
             parameters=params,
-            annotations=mcp_tool.annotations,
+            annotations=annotations,
         )
 
 
@@ -310,13 +326,21 @@ def func_to_basemodel(func: Callable) -> type[BaseModel]:
             )
             annotation = Any
 
+        # create_model() will error if the field name starts with `_` (since Pydantic
+        # uses this to indicate private fields). We can work around this by using an alias.
+        alias = None
+        if name.startswith("_"):
+            field_name, alias = (name.lstrip("_"), name)
+        else:
+            field_name, alias = (name, None)
+
         if param.default != inspect.Parameter.empty:
-            field = Field(default=param.default)
+            field = Field(default=param.default, alias=alias)
         else:
-            field = Field()
+            field = Field(alias=alias)
 
         # Add the field to our fields dict
-        fields[name] = (annotation, field)
+        fields[field_name] = (annotation, field)
 
     return create_model(func.__name__, **fields)
 

chatlas/_typing_extensions.py

@@ -13,7 +13,7 @@ else:
 # Even though TypedDict is available in Python 3.8, because it's used with NotRequired,
 # 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):
+if sys.version_info >= (3, 12):
     from typing import NotRequired, Required, TypedDict
 else:
     from typing_extensions import NotRequired, Required, TypedDict

chatlas/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.11.0'
-__version_tuple__ = version_tuple = (0, 11, 0)
+__version__ = version = '0.12.0'
+__version_tuple__ = version_tuple = (0, 12, 0)
 
 __commit_id__ = commit_id = None

chatlas/types/__init__.py

@@ -13,6 +13,8 @@ from .._content import (
     ContentToolRequest,
     ContentToolResult,
     ImageContentTypes,
+    ToolAnnotations,
+    ToolInfo,
 )
 from .._provider import ModelInfo
 from .._tokens import TokenUsage
@@ -32,6 +34,8 @@ __all__ = (
     "ImageContentTypes",
     "SubmitInputArgsT",
     "TokenUsage",
+    "ToolAnnotations",
+    "ToolInfo",
     "MISSING_TYPE",
     "MISSING",
     "ModelInfo",

chatlas/types/anthropic/_submit.py

@@ -3,7 +3,7 @@
 # ---------------------------------------------------------
 
 
-from typing import Iterable, Literal, Mapping, Optional, TypedDict, Union
+from typing import Iterable, Literal, Mapping, Optional, Sequence, TypedDict, Union
 
 import anthropic
 import anthropic.types.message_param
@@ -48,7 +48,7 @@ class SubmitInputArgs(TypedDict, total=False):
         str,
     ]
     service_tier: Union[Literal["auto", "standard_only"], anthropic.NotGiven]
-    stop_sequences: Union[list[str], anthropic.NotGiven]
+    stop_sequences: Union[Sequence[str], anthropic.NotGiven]
     stream: Union[Literal[False], Literal[True], anthropic.NotGiven]
     system: Union[
         str,

chatlas/types/openai/_client.py

@@ -3,14 +3,14 @@
 # ---------------------------------------------------------
 
 
-from typing import Mapping, Optional, TypedDict, Union
+from typing import Awaitable, Callable, Mapping, Optional, TypedDict, Union
 
 import httpx
 import openai
 
 
 class ChatClientArgs(TypedDict, total=False):
-    api_key: str | None
+    api_key: Union[str, Callable[[], Awaitable[str]], None]
     organization: str | None
     project: str | None
     webhook_secret: str | None

chatlas/types/openai/_client_azure.py

@@ -2,7 +2,7 @@
 # Do not modify this file. It was generated by `scripts/generate_typed_dicts.py`.
 # ---------------------------------------------------------
 
-from typing import Mapping, Optional, TypedDict
+from typing import Awaitable, Callable, Mapping, Optional, TypedDict, Union
 
 import httpx
 import openai
@@ -12,7 +12,7 @@ class ChatAzureClientArgs(TypedDict, total=False):
     azure_endpoint: str | None
     azure_deployment: str | None
     api_version: str | None
-    api_key: str | None
+    api_key: Union[str, Callable[[], Awaitable[str]], None]
     azure_ad_token: str | None
     organization: str | None
     project: str | None

chatlas/types/openai/_submit.py

@@ -3,7 +3,7 @@
 # ---------------------------------------------------------
 
 
-from typing import Iterable, Literal, Mapping, Optional, TypedDict, Union
+from typing import Iterable, Literal, Mapping, Optional, Sequence, TypedDict, Union
 
 import openai
 import openai.types.chat.chat_completion_allowed_tool_choice_param
@@ -148,7 +148,7 @@ class SubmitInputArgs(TypedDict, total=False):
     service_tier: Union[
         Literal["auto", "default", "flex", "scale", "priority"], None, openai.NotGiven
     ]
-    stop: Union[str, None, list[str], openai.NotGiven]
+    stop: Union[str, None, Sequence[str], openai.NotGiven]
     store: Union[bool, None, openai.NotGiven]
     stream: Union[Literal[False], None, Literal[True], openai.NotGiven]
     stream_options: Union[

{chatlas-0.11.0.dist-info → chatlas-0.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatlas
-Version: 0.11.0
+Version: 0.12.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

{chatlas-0.11.0.dist-info → chatlas-0.12.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
 chatlas/__init__.py,sha256=CyViGMiz50clcVu3vpZgOq_qP4hmoYGOlcHKlRPcLJo,2416
-chatlas/_auto.py,sha256=-s7XGzsKLX4RipWtk4WOE8iKbOBhXPUPtI0-63PpXCY,5660
+chatlas/_auto.py,sha256=aeMN2_EM-xK-Yx5JaCuwYRZZ29eqn_0oM7QR5zayrec,8912
 chatlas/_callbacks.py,sha256=3RpPaOQonTqScjXbaShgKJ1Rc-YxzWerxKRBjVssFnc,1838
-chatlas/_chat.py,sha256=HDNH_UA604sfyda-bVBs05GGs8-ISBwU4c2nM5bOd40,84997
-chatlas/_content.py,sha256=Hg4IQwoOXC72MaL3H-zpuN0JcBluEmsp2vstfSoBn_k,19984
+chatlas/_chat.py,sha256=pZOmlg0rqrzn7bi5QECAraG3ZA1MJPS0Ovk96wvgAGg,85712
+chatlas/_content.py,sha256=xi00PQgYi0hC2mTROOGVZiKfTkvlG9dud213iRQcwnY,22761
 chatlas/_content_image.py,sha256=EUK6wAint-JatLsiwvaPDu4D3W-NcIsDCkzABkXgfDg,8304
 chatlas/_content_pdf.py,sha256=cffeuJxzhUDukQ-Srkmpy62M8X12skYpU_FVq-Wvya4,2420
 chatlas/_display.py,sha256=wyQzSc6z1VqrJfkTLkw1wQcti9s1Pr4qT8UxFJESn4U,4664
@@ -29,26 +29,26 @@ chatlas/_provider_portkey.py,sha256=6wKrLZmKVxOqyO6P3HBgWqPe7y1N8une_1wp0aJq7pU,
 chatlas/_provider_snowflake.py,sha256=G66tG_zs_cIlrHaHY96GvBreTNHHk1O5012Y0BtYRqI,24578
 chatlas/_tokens.py,sha256=QUsBLNJPgXk8vovcG5JdQU8NarCv7FRpOVBdgFkBgHs,5388
 chatlas/_tokens_old.py,sha256=L9d9oafrXvEx2u4nIn_Jjn7adnQyLBnYBuPwJUE8Pl8,5005
-chatlas/_tools.py,sha256=SCmGP9bLHvVxQPznWfagG7GdzQamnyrPwYwDJ6EaWpw,11692
+chatlas/_tools.py,sha256=8rhGOsEviBJXk5Qb-a1RRb_C-DE2T3DOeN6IhblkxqI,12408
 chatlas/_turn.py,sha256=yK7alUxeP8d2iBc7amyz20BtEqcpvX6BCwWZsnlQ5R4,4515
-chatlas/_typing_extensions.py,sha256=MB9vWMWlm-IF8uOQfrTcfb66MV6gYXn3zgnbdwAC7BQ,1076
+chatlas/_typing_extensions.py,sha256=BXmbhywjm5ssmyVLGwyP_5TWZMAobzrrgZLYkB6_etE,1076
 chatlas/_utils.py,sha256=Kku2fa1mvTYCr5D28VxE6-fwfy2e2doCi-eKQkLEg4Y,4686
-chatlas/_version.py,sha256=9eKRDJ72C44i2IPiti-C7phzF429SwV2Nogzt0etpr0,706
+chatlas/_version.py,sha256=VDAgmYWykomGcTucvPJWNS0ePk26QojGHvaE9chtgGc,706
 chatlas/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 chatlas/data/prices.json,sha256=X6qALp-dWc4nfus9lIqHoKzk3PZDPHTLoxxcN2m6fXc,62645
-chatlas/types/__init__.py,sha256=4KWksOfX87xtkPWqTEV0qkCFij0UPJM39VNc00baiLc,776
+chatlas/types/__init__.py,sha256=1n0xrJ7TRIKsZ2z06FLFgGqfKMFtXSIxxPvJ2j0hvPw,850
 chatlas/types/anthropic/__init__.py,sha256=OwubA-DPHYpYo0XyRyAFwftOI0mOxtHzAyhUSLcDx54,417
 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/anthropic/_submit.py,sha256=X7ER31k7bTZGJ9X9u8Mx-X4enJC13W0VQzt8Wz-mLeQ,3675
 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=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.11.0.dist-info/METADATA,sha256=E10nf0f9IXxzwtqdX2cOyY4iygNcpmC5met5iL7ng5k,5594
-chatlas-0.11.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-chatlas-0.11.0.dist-info/licenses/LICENSE,sha256=zyuGzPOC7CcbOaBHsQ3UEyKYRO56KDUkor0OA4LqqDg,1081
-chatlas-0.11.0.dist-info/RECORD,,
+chatlas/types/openai/_client.py,sha256=mAoQftcJIp0ssIhS8q3TIW9u6zTRNtYDmpZJO8L0mC0,849
+chatlas/types/openai/_client_azure.py,sha256=Tf_PFRl0QAj4Nk5CD0ZNIO-SRsT39bVkEJlUTry1fb8,960
+chatlas/types/openai/_submit.py,sha256=EDtIUFcNIJ5QAt0wVyBXvUshK8FA9e86wcZDQ_HUOYs,7829
+chatlas-0.12.0.dist-info/METADATA,sha256=Xd9L5THh_2C6ckT6Khvn2B6js3JhT8WyCjlAp1JzOOc,5594
+chatlas-0.12.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+chatlas-0.12.0.dist-info/licenses/LICENSE,sha256=zyuGzPOC7CcbOaBHsQ3UEyKYRO56KDUkor0OA4LqqDg,1081
+chatlas-0.12.0.dist-info/RECORD,,