chatlas 0.9.2__tar.gz → 0.10.0__tar.gz

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

@@ -7,6 +7,26 @@ 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.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.10.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.10.0}/PKG-INFO

@@ -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 → chatlas-0.10.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.10.0}/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-0.9.2 → chatlas-0.10.0}/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-0.9.2 → chatlas-0.10.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-0.10.0/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-0.9.2 → chatlas-0.10.0}/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-0.10.0/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