chatlas 0.9.2__tar.gz → 0.11.0__tar.gz

{chatlas-0.9.2 → chatlas-0.11.0}/CHANGELOG.md

@@ -7,6 +7,41 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 -->
 
+## [0.11.0] - 2025-08-26
+
+### New features
+
+* The `Chat` class gains a new `.list_models()` method for obtaining a list of model ids/names, pricing info, and more. (#155)
+* `Chat`'s `.register_tool()` method gains an `annotations` parameter, which is useful for describing the tool and its behavior. This information is attached to `ContentToolRequest()` and `ContentToolResult()` (via the `.request` parameter) objects when tool calls occur. To include these objects in streaming content, make sure to set `.stream(content="all")`. (#156)
+
+### Improvements
+
+* Tools registered via MCP (e.g., `.register_mcp_tools_http_stream_async()`) now automatically pick up on tool annotations. (#156)
+
+### Changes
+
+* `ChatGithub()` changed its default for `base_url` from <https://models.inference.ai.azure.com> to <https://models.github.ai/inference/>. As a result, more models are available (by default). (#155)
+
+## [0.10.0] - 2025-08-19
+
+### New features
+
+* Added `ChatCloudflare()` for chatting via [Cloudflare AI](https://developers.cloudflare.com/workers-ai/get-started/rest-api/). (#150) 
+* Added `ChatDeepSeek()` for chatting via [DeepSeek](https://www.deepseek.com/). (#147)
+* Added `ChatOpenRouter()` for chatting via [Open Router](https://openrouter.ai/). (#148)
+* Added `ChatHuggingFace()` for chatting via [Hugging Face](https://huggingface.co/). (#144)
+* Added `ChatMistral()` for chatting via [Mistral AI](https://mistral.ai/). (#145)
+* Added `ChatPortkey()` for chatting via [Portkey AI](https://portkey.ai/). (#143)
+
+### Changes
+
+* `ChatAnthropic()` and `ChatBedrockAnthropic()` now default to Claude Sonnet 4.0.
+
+### Bug fixes
+
+* Fixed an issue where chatting with some models was leading to `KeyError: 'cached_input'`. (#149)
+
+
 ## [0.9.2] - 2025-08-08
 
 ### Improvements

chatlas-0.11.0/CLAUDE.md

@@ -0,0 +1,167 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Development Commands
+
+The project uses `uv` for package management and Make for common tasks:
+
+- **Setup environment**: `make setup` (installs all dependencies with `uv sync --all-extras`)
+- **Run tests**: `make check-tests` or `uv run pytest`
+- **Type checking**: `make check-types` or `uv run pyright`
+- **Linting/formatting**: `make check-format` (check) or `make format` (fix)
+- **Full checks**: `make check` (runs format, type, and test checks)
+- **Build package**: `make build` (creates dist/ with built package)
+- **Run single test**: `uv run pytest tests/test_specific_file.py::TestClass::test_method -v`
+- **Update snapshots**: `make update-snaps` (for syrupy snapshot tests)
+- **Documentation**: `make docs` (build) or `make docs-preview` (serve locally)
+
+## Project Architecture
+
+### Core Components
+
+**Chat System**: The main `Chat` class in `_chat.py` manages conversation state and provider interactions. It's a generic class that works with different providers through the `Provider` abstract base class.
+
+**Provider Pattern**: All LLM providers (OpenAI, Anthropic, Google, etc.) inherit from `Provider` in `_provider.py`. Each provider (e.g., `_provider_openai.py`) implements:
+- Model-specific parameter handling 
+- API client configuration
+- Request/response transformation
+- Tool calling integration
+
+**Content System**: The `_content.py` module defines structured content types:
+- `ContentText`: Plain text messages
+- `ContentImage`: Image content (inline, remote, or file-based)
+- `ContentToolRequest`/`ContentToolResult`: Tool interaction messages
+- `ContentJson`: Structured data responses
+
+**Tool System**: Tools are defined in `_tools.py` and allow LLMs to call Python functions. The system supports:
+- Function registration with automatic schema generation
+- Tool approval workflows
+- MCP (Model Context Protocol) server integration via `_mcp_manager.py`
+
+**Turn Management**: `Turn` objects in `_turn.py` represent individual conversation exchanges, containing sequences of `Content` objects.
+
+### Key Patterns
+
+1. **Provider Abstraction**: All providers implement the same interface but handle model-specific details internally
+2. **Generic Typing**: Heavy use of TypeVars and generics for type safety across providers
+3. **Streaming Support**: Both sync and async streaming responses via `ChatResponse`/`ChatResponseAsync`
+4. **Content-Based Messaging**: All communication uses structured `Content` objects rather than raw strings
+5. **Tool Integration**: Seamless function calling with automatic JSON schema generation from Python type hints
+
+### Testing Structure
+
+- Tests are organized by component (e.g., `test_provider_openai.py`, `test_tools.py`)
+- Snapshot testing with `syrupy` for response validation
+- MCP server tests use local test servers in `tests/mcp_servers/`
+- Async tests configured via `pytest.ini` with `asyncio_mode=strict`
+
+### Documentation
+
+Documentation is built with Quarto and quartodoc:
+- API reference generated from docstrings in `chatlas/` modules
+- Guides and examples in `docs/` as `.qmd` files
+- Type definitions in `chatlas/types/` provide provider-specific parameter types
+
+
+## Adding New Providers
+
+When implementing a new LLM provider, follow this systematic approach:
+
+### 1. Research Phase
+- **Check ellmer first**: Look in `../ellmer/R/provider-*.R` for existing implementations
+- **Identify base provider**: Most providers inherit from either `OpenAIProvider` (for OpenAI-compatible APIs) or implement `Provider` directly
+- **Check existing patterns**: Review similar providers in `chatlas/_provider_*.py`
+
+### 2. Implementation Steps
+1. **Create provider file**: `chatlas/_provider_[name].py`
+   - Use PascalCase for class names (e.g., `MistralProvider`)  
+   - Use snake_case for function names (e.g., `ChatMistral`)
+   - Follow existing docstring patterns with Prerequisites, Examples, Parameters, Returns sections
+   
+2. **Provider class structure**:
+   ```python
+   class [Name]Provider(OpenAIProvider):  # or Provider if custom
+       def __init__(self, ...):
+           super().__init__(...)
+           # Provider-specific initialization
+       
+       def _chat_perform_args(self, ...):
+           # Customize request parameters if needed
+           kwargs = super()._chat_perform_args(...)
+           # Apply provider-specific modifications
+           return kwargs
+   ```
+
+3. **Chat function signature**:
+   ```python
+   def Chat[Name](
+       *,
+       system_prompt: Optional[str] = None,
+       model: Optional[str] = None,
+       api_key: Optional[str] = None,
+       base_url: str = "https://...",
+       seed: int | None | MISSING_TYPE = MISSING,
+       kwargs: Optional["ChatClientArgs"] = None,
+   ) -> Chat["SubmitInputArgs", ChatCompletion]:
+   ```
+
+### 3. Testing Setup
+1. **Create test file**: `tests/test_provider_[name].py`
+2. **Add environment variable skip pattern**:
+   ```python
+   import os
+   import pytest
+   
+   do_test = os.getenv("TEST_[NAME]", "true")
+   if do_test.lower() == "false":
+       pytest.skip("Skipping [Name] tests", allow_module_level=True)
+   ```
+3. **Use standard test patterns**:
+   - `test_[name]_simple_request()`
+   - `test_[name]_simple_streaming_request()`  
+   - `test_[name]_respects_turns_interface()`
+   - `test_[name]_tool_variations()` (if supported)
+   - `test_data_extraction()`
+   - `test_[name]_images()` (if vision supported)
+
+### 4. Package Integration
+1. **Update `chatlas/__init__.py`**:
+   - Add import: `from ._provider_[name] import Chat[Name]`
+   - Add to `__all__` tuple: `"Chat[Name]"`
+
+2. **Run validation**:
+   ```bash
+   uv run pyright chatlas/_provider_[name].py
+   TEST_[NAME]=false uv run pytest tests/test_provider_[name].py -v
+   uv run python -c "from chatlas import Chat[Name]; print('Import successful')"
+   ```
+
+### 5. Provider-Specific Customizations
+
+**OpenAI-Compatible Providers**:
+- Inherit from `OpenAIProvider`
+- Override `_chat_perform_args()` for API differences
+- Common customizations: remove `stream_options`, adjust parameter names, modify headers
+
+**Custom API Providers**:
+- Inherit from `Provider` directly
+- Implement all abstract methods: `chat_perform()`, `chat_perform_async()`, `stream_text()`, etc.
+- Handle model-specific response formats
+
+### 6. Common Patterns
+- **Environment variables**: Use `[PROVIDER]_API_KEY` format
+- **Default models**: Use provider's recommended general-purpose model
+- **Seed handling**: `seed = 1014 if is_testing() else None` when MISSING
+- **Error handling**: Provider APIs often return different error formats
+- **Rate limiting**: Consider implementing client-side throttling for providers that need it
+
+### 7. Documentation Requirements
+- Include provider description and prerequisites
+- Document known limitations (tool calling, vision support, etc.)
+- Provide working examples with environment variable usage
+- Note any special model requirements (e.g., vision models for images)
+
+## Connections to ellmer
+
+This project is the Python equivalent of the R package ellmer. The source code for ellmer is available in a sibling directory to this project. Before implementing new features or bug fixes in chatlas, it may be useful to consult  the ellmer codebase to: (1) check whether the feature/fix already exists on the R side and (2) make sure the projects are aligned in terms of stylistic approaches. Note also that ellmer itself has a CLAUDE.md file which has a useful overview of the project. 

{chatlas-0.9.2 → chatlas-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: chatlas
-Version: 0.9.2
+Version: 0.11.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 → chatlas-0.11.0}/README.md

@@ -1,4 +1,4 @@
-# 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 -->
@@ -54,7 +54,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 → chatlas-0.11.0}/chatlas/__init__.py

@@ -1,19 +1,30 @@
 from . import types
 from ._auto import ChatAuto
 from ._chat import Chat
-from ._content import ContentToolRequest, ContentToolResult, ContentToolResultImage
+from ._content import (
+    ContentToolRequest,
+    ContentToolResult,
+    ContentToolResultImage,
+    ContentToolResultResource,
+)
 from ._content_image import content_image_file, content_image_plot, content_image_url
 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 +39,20 @@ __all__ = (
     "ChatAnthropic",
     "ChatAuto",
     "ChatBedrockAnthropic",
+    "ChatCloudflare",
     "ChatDatabricks",
+    "ChatDeepSeek",
     "ChatGithub",
     "ChatGoogle",
     "ChatGroq",
+    "ChatHuggingFace",
+    "ChatMistral",
     "ChatOllama",
     "ChatOpenAI",
+    "ChatOpenRouter",
     "ChatAzureOpenAI",
     "ChatPerplexity",
+    "ChatPortkey",
     "ChatSnowflake",
     "ChatVertex",
     "Chat",
@@ -47,6 +64,7 @@ __all__ = (
     "ContentToolRequest",
     "ContentToolResult",
     "ContentToolResultImage",
+    "ContentToolResultResource",
     "interpolate",
     "interpolate_file",
     "Provider",
@@ -56,3 +74,9 @@ __all__ = (
     "Turn",
     "types",
 )
+
+# Rebuild content models to resolve forward references to ToolAnnotation
+ContentToolRequest.model_rebuild()
+ContentToolResult.model_rebuild()
+ContentToolResultImage.model_rebuild()
+ContentToolResultResource.model_rebuild()

{chatlas-0.9.2 → chatlas-0.11.0}/chatlas/_chat.py

@@ -9,6 +9,7 @@ import warnings
 from pathlib import Path
 from threading import Thread
 from typing import (
+    TYPE_CHECKING,
     Any,
     AsyncGenerator,
     AsyncIterator,
@@ -43,13 +44,16 @@ from ._display import (
 )
 from ._logging import log_tool_error
 from ._mcp_manager import MCPSessionManager
-from ._provider import Provider, StandardModelParams, SubmitInputArgsT
+from ._provider import ModelInfo, Provider, StandardModelParams, SubmitInputArgsT
 from ._tokens import compute_cost, get_token_pricing
 from ._tools import Tool, ToolRejectError
 from ._turn import Turn, user_turn
 from ._typing_extensions import TypedDict, TypeGuard
 from ._utils import MISSING, MISSING_TYPE, html_escape, wrap_async
 
+if TYPE_CHECKING:
+    from mcp.types import ToolAnnotations
+
 
 class TokensDict(TypedDict):
     """
@@ -128,6 +132,78 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         self._standard_model_params: StandardModelParams = {}
         self._submit_input_kwargs: Optional[SubmitInputArgsT] = None
 
+    def list_models(self) -> list[ModelInfo]:
+        """
+        List all models available for the provider.
+
+        This method returns detailed information about all models supported by the provider,
+        including model IDs, pricing information, creation dates, and other metadata. This is
+        useful for discovering available models and their characteristics without needing to
+        consult provider documentation.
+
+        Examples
+        --------
+        Get all available models:
+
+        ```python
+        from chatlas import ChatOpenAI
+
+        chat = ChatOpenAI()
+        models = chat.list_models()
+        print(f"Found {len(models)} models")
+        print(f"First model: {models[0]['id']}")
+        ```
+
+        View models in a table format:
+
+        ```python
+        import pandas as pd
+        from chatlas import ChatAnthropic
+
+        chat = ChatAnthropic()
+        df = pd.DataFrame(chat.list_models())
+        print(df[["id", "input", "output"]].head())  # Show pricing info
+        ```
+
+        Find models by criteria:
+
+        ```python
+        from chatlas import ChatGoogle
+
+        chat = ChatGoogle()
+        models = chat.list_models()
+
+        # Find cheapest input model
+        cheapest = min(models, key=lambda m: m.get("input", float("inf")))
+        print(f"Cheapest model: {cheapest['id']}")
+        ```
+
+        Returns
+        -------
+        list[ModelInfo]
+            A list of ModelInfo dictionaries containing model information. Each dictionary
+            contains:
+
+            - `id` (str): The model identifier to use with the Chat constructor
+            - `name` (str, optional): Human-readable model name
+            - `input` (float, optional): Cost per input token in USD per million tokens
+            - `output` (float, optional): Cost per output token in USD per million tokens
+            - `cached_input` (float, optional): Cost per cached input token in USD per million tokens
+            - `created_at` (date, optional): Date the model was created
+            - `owned_by` (str, optional): Organization that owns the model
+            - `provider` (str, optional): Model provider name
+            - `size` (int, optional): Model size in bytes
+            - `url` (str, optional): URL with more information about the model
+
+            The list is typically sorted by creation date (most recent first).
+
+        Note
+        ----
+        Not all providers support this method. Some providers may raise NotImplementedError
+        with information about where to find model listings online.
+        """
+        return self.provider.list_models()
+
     def get_turns(
         self,
         *,
@@ -395,8 +471,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
@@ -1462,6 +1538,7 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         *,
         force: bool = False,
         model: Optional[type[BaseModel]] = None,
+        annotations: "Optional[ToolAnnotations]" = None,
     ):
         """
         Register a tool (function) with the chat.
@@ -1539,13 +1616,16 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             The primary reason why you might want to provide a model in
             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.
 
         Raises
         ------
         ValueError
             If a tool with the same name already exists and `force` is `False`.
         """
-        tool = Tool.from_func(func, model=model)
+        tool = Tool.from_func(func, model=model, annotations=annotations)
         if tool.name in self._tools and not force:
             raise ValueError(
                 f"Tool with name '{tool.name}' is already registered. "
@@ -1853,6 +1933,7 @@ 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)
                     if echo == "output":
                         self._echo_content(f"\n\n{x}\n\n")
                     if content == "all":
@@ -1913,6 +1994,7 @@ 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)
                     if echo == "output":
                         self._echo_content(f"\n\n{x}\n\n")
                     if content == "all":
@@ -2070,8 +2152,8 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
         self._turns.extend([user_turn, turn])
 
     def _invoke_tool(self, request: ContentToolRequest):
-        tool_def = self._tools.get(request.name, None)
-        func = tool_def.func if tool_def is not None else None
+        tool = request.tool
+        func = tool.func if tool is not None else None
 
         if func is None:
             yield self._handle_tool_error_result(
@@ -2118,21 +2200,20 @@ class Chat(Generic[SubmitInputArgsT, CompletionT]):
             yield self._handle_tool_error_result(request, e)
 
     async def _invoke_tool_async(self, request: ContentToolRequest):
-        tool_def = self._tools.get(request.name, None)
-        func = None
-        if tool_def:
-            if tool_def._is_async:
-                func = tool_def.func
-            else:
-                func = wrap_async(tool_def.func)
+        tool = request.tool
 
-        if func is None:
+        if tool is None:
             yield self._handle_tool_error_result(
                 request,
                 error=RuntimeError("Unknown tool."),
             )
             return
 
+        if tool._is_async:
+            func = tool.func
+        else:
+            func = wrap_async(tool.func)
+
         # First, invoke the request callbacks. If a ToolRejectError is raised,
         # treat it like a tool failure (i.e., gracefully handle it).
         result: ContentToolResult | None = None

{chatlas-0.9.2 → chatlas-0.11.0}/chatlas/_content.py

@@ -1,11 +1,14 @@
 from __future__ import annotations
 
 from pprint import pformat
-from typing import Any, Literal, Optional, Union
+from typing import TYPE_CHECKING, Any, Literal, Optional, Union
 
 import orjson
 from pydantic import BaseModel, ConfigDict
 
+if TYPE_CHECKING:
+    from ._tools import Tool
+
 ImageContentTypes = Literal[
     "image/png",
     "image/jpeg",
@@ -171,11 +174,15 @@ class ContentToolRequest(Content):
         The name of the tool/function to call.
     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.
     """
 
     id: str
     name: str
     arguments: object
+    tool: Optional["Tool"] = None
 
     content_type: ContentTypeEnum = "tool_request"
 

{chatlas-0.9.2 → chatlas-0.11.0}/chatlas/_provider.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
+from datetime import date
 from typing import (
     AsyncIterable,
     Generic,
@@ -16,7 +17,7 @@ from pydantic import BaseModel
 from ._content import Content
 from ._tools import Tool
 from ._turn import Turn
-from ._typing_extensions import TypedDict
+from ._typing_extensions import NotRequired, TypedDict
 
 ChatCompletionT = TypeVar("ChatCompletionT")
 ChatCompletionChunkT = TypeVar("ChatCompletionChunkT")
@@ -35,6 +36,40 @@ submitting input to a model provider.
 """
 
 
+class ModelInfo(TypedDict):
+    "Information returned from the `.list_models()` method"
+
+    id: str
+    "The model ID (this gets passed to the `model` parameter of the `Chat` constructor)"
+
+    cached_input: NotRequired[float | None]
+    "The cost per user token in USD per million tokens for cached input"
+
+    input: NotRequired[float | None]
+    "The cost per user token in USD per million tokens"
+
+    output: NotRequired[float | None]
+    "The cost per assistant token in USD per million tokens"
+
+    created_at: NotRequired[date]
+    "The date the model was created"
+
+    name: NotRequired[str]
+    "The model name"
+
+    owned_by: NotRequired[str]
+    "The owner of the model"
+
+    size: NotRequired[int]
+    "The size of the model in bytes"
+
+    provider: NotRequired[str]
+    "The provider of the model"
+
+    url: NotRequired[str]
+    "A URL to learn more about the model"
+
+
 class StandardModelParams(TypedDict, total=False):
     """
     A TypedDict representing the standard model parameters that can be set
@@ -102,6 +137,13 @@ class Provider(
         """
         return self._model
 
+    @abstractmethod
+    def list_models(self) -> list[ModelInfo]:
+        """
+        List all available models for the provider.
+        """
+        pass
+
     @overload
     @abstractmethod
     def chat_perform(