chatlas 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

chatlas/__init__.py

@@ -2,7 +2,7 @@ from . import types
 from ._anthropic import ChatAnthropic, ChatBedrockAnthropic
 from ._auto import ChatAuto
 from ._chat import Chat
-from ._content import ContentToolRequest, ContentToolResult
+from ._content import ContentToolRequest, ContentToolResult, ContentToolResultImage
 from ._content_image import content_image_file, content_image_plot, content_image_url
 from ._content_pdf import content_pdf_file, content_pdf_url
 from ._databricks import ChatDatabricks
@@ -46,6 +46,7 @@ __all__ = (
     "content_pdf_url",
     "ContentToolRequest",
     "ContentToolResult",
+    "ContentToolResultImage",
     "interpolate",
     "interpolate_file",
     "Provider",

chatlas/_anthropic.py

@@ -17,12 +17,15 @@ from ._content import (
     ContentText,
     ContentToolRequest,
     ContentToolResult,
+    ContentToolResultImage,
+    ContentToolResultResource,
 )
 from ._logging import log_model_default
-from ._provider import Provider
+from ._provider import Provider, StandardModelParamNames, StandardModelParams
 from ._tokens import tokens_log
 from ._tools import Tool, basemodel_to_param_schema
-from ._turn import Turn, normalize_turns, user_turn
+from ._turn import Turn, user_turn
+from ._utils import split_http_client_kwargs
 
 if TYPE_CHECKING:
     from anthropic.types import (
@@ -58,7 +61,6 @@ else:
 def ChatAnthropic(
     *,
     system_prompt: Optional[str] = None,
-    turns: Optional[list[Turn]] = None,
     model: "Optional[ModelParam]" = None,
     api_key: Optional[str] = None,
     max_tokens: int = 4096,
@@ -104,13 +106,6 @@ def ChatAnthropic(
     ----------
     system_prompt
         A system prompt to set the behavior of the assistant.
-    turns
-        A list of turns to start the chat with (i.e., continuing a previous
-        conversation). If not provided, the conversation begins from scratch. Do
-        not provide non-None values for both `turns` and `system_prompt`. Each
-        message in the list should be a dictionary with at least `role` (usually
-        `system`, `user`, or `assistant`, but `tool` is also possible). Normally
-        there is also a `content` field, which is a string.
     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
@@ -177,22 +172,23 @@ def ChatAnthropic(
             max_tokens=max_tokens,
             kwargs=kwargs,
         ),
-        turns=normalize_turns(
-            turns or [],
-            system_prompt,
-        ),
+        system_prompt=system_prompt,
     )
 
 
-class AnthropicProvider(Provider[Message, RawMessageStreamEvent, Message]):
+class AnthropicProvider(
+    Provider[Message, RawMessageStreamEvent, Message, "SubmitInputArgs"]
+):
     def __init__(
         self,
         *,
-        max_tokens: int,
+        max_tokens: int = 4096,
         model: str,
-        api_key: str | None,
+        api_key: Optional[str] = None,
+        name: str = "Anthropic",
         kwargs: Optional["ChatClientArgs"] = None,
     ):
+        super().__init__(name=name, model=model)
         try:
             from anthropic import Anthropic, AsyncAnthropic
         except ImportError:
@@ -200,8 +196,6 @@ class AnthropicProvider(Provider[Message, RawMessageStreamEvent, Message]):
                 "`ChatAnthropic()` requires the `anthropic` package. "
                 "You can install it with 'pip install anthropic'."
             )
-
-        self._model = model
         self._max_tokens = max_tokens
 
         kwargs_full: "ChatClientArgs" = {
@@ -209,9 +203,11 @@ class AnthropicProvider(Provider[Message, RawMessageStreamEvent, Message]):
             **(kwargs or {}),
         }
 
+        sync_kwargs, async_kwargs = split_http_client_kwargs(kwargs_full)
+
         # TODO: worth bringing in sync types?
-        self._client = Anthropic(**kwargs_full)  # type: ignore
-        self._async_client = AsyncAnthropic(**kwargs_full)
+        self._client = Anthropic(**sync_kwargs)  # type: ignore
+        self._async_client = AsyncAnthropic(**async_kwargs)
 
     @overload
     def chat_perform(
@@ -301,7 +297,7 @@ class AnthropicProvider(Provider[Message, RawMessageStreamEvent, Message]):
                 """Extract structured data"""
                 pass
 
-            data_model_tool = Tool(_structured_tool_call)
+            data_model_tool = Tool.from_func(_structured_tool_call)
 
             data_model_tool.schema["function"]["parameters"] = {
                 "type": "object",
@@ -322,7 +318,7 @@ class AnthropicProvider(Provider[Message, RawMessageStreamEvent, Message]):
         kwargs_full: "SubmitInputArgs" = {
             "stream": stream,
             "messages": self._as_message_params(turns),
-            "model": self._model,
+            "model": self.model,
             "max_tokens": self._max_tokens,
             "tools": tool_schemas,
             **(kwargs or {}),
@@ -435,6 +431,34 @@ class AnthropicProvider(Provider[Message, RawMessageStreamEvent, Message]):
 
         return {arg: kwargs[arg] for arg in args_to_keep if arg in kwargs}
 
+    def translate_model_params(self, params: StandardModelParams) -> "SubmitInputArgs":
+        res: "SubmitInputArgs" = {}
+        if "temperature" in params:
+            res["temperature"] = params["temperature"]
+
+        if "top_p" in params:
+            res["top_p"] = params["top_p"]
+
+        if "top_k" in params:
+            res["top_k"] = params["top_k"]
+
+        if "max_tokens" in params:
+            res["max_tokens"] = params["max_tokens"]
+
+        if "stop_sequences" in params:
+            res["stop_sequences"] = params["stop_sequences"]
+
+        return res
+
+    def supported_model_params(self) -> set[StandardModelParamNames]:
+        return {
+            "temperature",
+            "top_p",
+            "top_k",
+            "max_tokens",
+            "stop_sequences",
+        }
+
     def _as_message_params(self, turns: list[Turn]) -> list["MessageParam"]:
         messages: list["MessageParam"] = []
         for turn in turns:
@@ -473,10 +497,13 @@ class AnthropicProvider(Provider[Message, RawMessageStreamEvent, Message]):
                 },
             }
         elif isinstance(content, ContentImageRemote):
-            raise NotImplementedError(
-                "Remote images aren't supported by Anthropic (Claude). "
-                "Consider downloading the image and using content_image_file() instead."
-            )
+            return {
+                "type": "image",
+                "source": {
+                    "type": "url",
+                    "url": content.url,
+                },
+            }
         elif isinstance(content, ContentToolRequest):
             return {
                 "type": "tool_use",
@@ -490,8 +517,26 @@ class AnthropicProvider(Provider[Message, RawMessageStreamEvent, Message]):
                 "tool_use_id": content.id,
                 "is_error": content.error is not None,
             }
-            # Anthropic supports non-text contents like ImageBlockParam
-            res["content"] = content.get_model_value()  # type: ignore
+
+            if isinstance(content, ContentToolResultImage):
+                res["content"] = [
+                    {
+                        "type": "image",
+                        "source": {
+                            "type": "base64",
+                            "media_type": content.mime_type,
+                            "data": content.value,
+                        },
+                    }
+                ]
+            elif isinstance(content, ContentToolResultResource):
+                raise NotImplementedError(
+                    "ContentToolResultResource is not currently supported by Anthropic."
+                )
+            else:
+                # Anthropic supports non-text contents like ImageBlockParam
+                res["content"] = content.get_model_value()  # type: ignore
+
             return res
 
         raise ValueError(f"Unknown content type: {type(content)}")
@@ -565,7 +610,6 @@ def ChatBedrockAnthropic(
     aws_session_token: Optional[str] = None,
     base_url: Optional[str] = None,
     system_prompt: Optional[str] = None,
-    turns: Optional[list[Turn]] = None,
     kwargs: Optional["ChatBedrockClientArgs"] = None,
 ) -> Chat["SubmitInputArgs", Message]:
     """
@@ -631,13 +675,6 @@ def ChatBedrockAnthropic(
         `f"https://bedrock-runtime.{aws_region}.amazonaws.com"`.
     system_prompt
         A system prompt to set the behavior of the assistant.
-    turns
-        A list of turns to start the chat with (i.e., continuing a previous
-        conversation). If not provided, the conversation begins from scratch. Do
-        not provide non-None values for both `turns` and `system_prompt`. Each
-        message in the list should be a dictionary with at least `role` (usually
-        `system`, `user`, or `assistant`, but `tool` is also possible). Normally
-        there is also a `content` field, which is a string.
     kwargs
         Additional arguments to pass to the `anthropic.AnthropicBedrock()`
         client constructor.
@@ -711,10 +748,7 @@ def ChatBedrockAnthropic(
             base_url=base_url,
             kwargs=kwargs,
         ),
-        turns=normalize_turns(
-            turns or [],
-            system_prompt,
-        ),
+        system_prompt=system_prompt,
     )
 
 
@@ -728,10 +762,13 @@ class AnthropicBedrockProvider(AnthropicProvider):
         aws_region: str | None,
         aws_profile: str | None,
         aws_session_token: str | None,
-        max_tokens: int,
+        max_tokens: int = 4096,
         base_url: str | None,
+        name: str = "AnthropicBedrock",
         kwargs: Optional["ChatBedrockClientArgs"] = None,
     ):
+        super().__init__(name=name, model=model, max_tokens=max_tokens)
+
         try:
             from anthropic import AnthropicBedrock, AsyncAnthropicBedrock
         except ImportError:
@@ -740,9 +777,6 @@ class AnthropicBedrockProvider(AnthropicProvider):
                 "Install it with `pip install anthropic[bedrock]`."
             )
 
-        self._model = model
-        self._max_tokens = max_tokens
-
         kwargs_full: "ChatBedrockClientArgs" = {
             "aws_secret_key": aws_secret_key,
             "aws_access_key": aws_access_key,

chatlas/_auto.py

@@ -15,7 +15,6 @@ from ._ollama import ChatOllama
 from ._openai import ChatAzureOpenAI, ChatOpenAI
 from ._perplexity import ChatPerplexity
 from ._snowflake import ChatSnowflake
-from ._turn import Turn
 
 AutoProviders = Literal[
     "anthropic",
@@ -50,7 +49,6 @@ _provider_chat_model_map: dict[AutoProviders, Callable[..., Chat]] = {
 
 def ChatAuto(
     system_prompt: Optional[str] = None,
-    turns: Optional[list[Turn]] = None,
     *,
     provider: Optional[AutoProviders] = None,
     model: Optional[str] = None,
@@ -111,6 +109,8 @@ def ChatAuto(
 
     Parameters
     ----------
+    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
@@ -123,15 +123,6 @@ def ChatAuto(
         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.
-    system_prompt
-        A system prompt to set the behavior of the assistant.
-    turns
-        A list of turns to start the chat with (i.e., continuing a previous
-        conversation). If not provided, the conversation begins from scratch. Do
-        not provide non-`None` values for both `turns` and `system_prompt`. Each
-        message in the list should be a dictionary with at least `role` (usually
-        `system`, `user`, or `assistant`, but `tool` is also possible). Normally
-        there is also a `content` field, which is a string.
     **kwargs
         Additional keyword arguments to pass to the Chat constructor. See the
         documentation for each provider for more details on the available
@@ -169,7 +160,7 @@ def ChatAuto(
         )
 
     # `system_prompt` and `turns` always come from `ChatAuto()`
-    base_args = {"system_prompt": system_prompt, "turns": turns}
+    base_args = {"system_prompt": system_prompt}
 
     if env_model := os.environ.get("CHATLAS_CHAT_MODEL"):
         model = env_model