chore: remove dependency on anthropic types

philipph-askui · philipph-askui · commit 00d359c29d54 · 2026-01-21T11:24:32.000+01:00
diff --git a/src/askui/models/anthropic/messages_api.py b/src/askui/models/anthropic/messages_api.py
@@ -1,4 +1,4 @@
-from typing import cast
+from typing import Tuple, cast
 
 from anthropic import (
     APIConnectionError,
@@ -13,6 +13,7 @@
     BetaMessageParam,
     BetaThinkingConfigParam,
     BetaToolChoiceParam,
+    BetaToolUnionParam,
 )
 from tenacity import retry, retry_if_exception, stop_after_attempt, wait_exponential
 from typing_extensions import override
@@ -23,7 +24,11 @@
     RETRYABLE_HTTP_STATUS_CODES,
     wait_for_retry_after_header,
 )
-from askui.models.shared.agent_message_param import MessageParam
+from askui.models.shared.agent_message_param import (
+    MessageParam,
+    ThinkingConfigParam,
+    ToolChoiceParam,
+)
 from askui.models.shared.messages_api import MessagesApi
 from askui.models.shared.prompts import SystemPrompt
 from askui.models.shared.tools import ToolCollection
@@ -36,6 +41,47 @@ def _is_retryable_error(exception: BaseException) -> bool:
     return isinstance(exception, (APIConnectionError, APITimeoutError, APIError))
 
 
+def _parse_to_anthropic_types(
+    tools: ToolCollection | None,
+    betas: list[str] | None = None,
+    system: SystemPrompt | None = None,
+    thinking: ThinkingConfigParam | None = None,
+    tool_choice: ToolChoiceParam | None = None,
+    temperature: float | None = None,
+) -> Tuple[
+    list[BetaToolUnionParam] | Omit,
+    list[AnthropicBetaParam] | Omit,
+    str | Omit,
+    BetaThinkingConfigParam | Omit,
+    BetaToolChoiceParam | Omit,
+    float | Omit,
+]:
+    """Convert provider-agnostic types to Anthropic-specific types.
+
+    This function bridges the gap between the generic MessagesApi interface
+    and Anthropic's specific type requirements. The input dicts should match
+    Anthropic's expected structure (see Anthropic SDK documentation).
+    """
+    _tools = (
+        cast("list[BetaToolUnionParam]", tools.to_params())
+        if tools is not None
+        else omit
+    )
+    _betas = cast("list[AnthropicBetaParam]", betas) or omit
+    _system: str | Omit = omit if system is None else str(system)
+    # Cast dicts to Anthropic's TypedDict types
+    # Runtime validation happens in Anthropic SDK
+    _thinking = (
+        cast("BetaThinkingConfigParam", thinking) if thinking is not None else omit
+    )
+    _tool_choice = (
+        cast("BetaToolChoiceParam", tool_choice) if tool_choice is not None else omit
+    )
+    _temperature = temperature or omit
+
+    return (_tools, _betas, _system, _thinking, _tool_choice, _temperature)
+
+
 class AnthropicMessagesApi(MessagesApi):
     def __init__(
         self,
@@ -45,7 +91,6 @@ def __init__(
         self._client = client
         self._locator_serializer = locator_serializer
 
-    @override
     @retry(
         stop=stop_after_attempt(4),  # 3 retries
         wait=wait_for_retry_after_header(
@@ -59,30 +104,35 @@ def create_message(
         self,
         messages: list[MessageParam],
         model_id: str,
-        tools: ToolCollection | Omit = omit,
-        max_tokens: int | Omit = omit,
-        betas: list[AnthropicBetaParam] | Omit = omit,
+        tools: ToolCollection | None = None,
+        max_tokens: int | None = None,
+        betas: list[str] | None = None,
         system: SystemPrompt | None = None,
-        thinking: BetaThinkingConfigParam | Omit = omit,
-        tool_choice: BetaToolChoiceParam | Omit = omit,
-        temperature: float | Omit = omit,
+        thinking: ThinkingConfigParam | None = None,
+        tool_choice: ToolChoiceParam | None = None,
+        temperature: float | None = None,
     ) -> MessageParam:
         _messages = [
             cast("BetaMessageParam", message.model_dump(exclude={"stop_reason"}))
             for message in messages
         ]
-        _system: str | Omit = omit if system is None else str(system)
+
+        _tools, _betas, _system, _thinking, _tool_choice, _temperature = (
+            _parse_to_anthropic_types(
+                tools, betas, system, thinking, tool_choice, temperature
+            )
+        )
 
         response = self._client.beta.messages.create(  # type: ignore[misc]
             messages=_messages,
             max_tokens=max_tokens or 8192,
             model=model_id,
-            tools=tools.to_params() if not isinstance(tools, Omit) else omit,
-            betas=betas,
+            tools=_tools,
+            betas=_betas,
             system=_system,
-            thinking=thinking,
-            tool_choice=tool_choice,
-            temperature=temperature,
+            thinking=_thinking,
+            tool_choice=_tool_choice,
+            temperature=_temperature,
             timeout=300.0,
         )
         return MessageParam.model_validate(response.model_dump())
diff --git a/src/askui/models/shared/agent_message_param.py b/src/askui/models/shared/agent_message_param.py
@@ -1,3 +1,5 @@
+from typing import Any
+
 from pydantic import BaseModel
 from typing_extensions import Literal
 
@@ -104,6 +106,13 @@ class BetaRedactedThinkingBlock(BaseModel):
     "end_turn", "max_tokens", "stop_sequence", "tool_use", "pause_turn", "refusal"
 ]
 
+# Generic type aliases for provider-agnostic API
+# Different providers (Anthropic, OpenAI, etc.) have different structures
+# Using dict[str, Any] allows flexibility for different provider requirements
+ThinkingConfigParam = dict[str, Any]
+ToolChoiceParam = dict[str, Any]
+ToolParam = dict[str, Any]
+
 
 class MessageParam(BaseModel):
     role: Literal["user", "assistant"]
@@ -125,4 +134,6 @@ class MessageParam(BaseModel):
     "ToolResultBlockParam",
     "ToolUseBlockParam",
     "UrlImageSourceParam",
+    "ThinkingConfigParam",
+    "ToolChoiceParam",
 ]
diff --git a/src/askui/models/shared/messages_api.py b/src/askui/models/shared/messages_api.py
@@ -1,6 +1,10 @@
 from abc import ABC, abstractmethod
 
-from askui.models.shared.agent_message_param import MessageParam
+from askui.models.shared.agent_message_param import (
+    MessageParam,
+    ThinkingConfigParam,
+    ToolChoiceParam,
+)
 from askui.models.shared.prompts import SystemPrompt
 from askui.models.shared.tools import ToolCollection
 
@@ -17,24 +21,30 @@ def create_message(
         max_tokens: int | None = None,
         betas: list[str] | None = None,
         system: SystemPrompt | None = None,
-        thinking: dict[str, str] | None = None,
-        tool_choice: dict[str, str] | None = None,
+        thinking: ThinkingConfigParam | None = None,
+        tool_choice: ToolChoiceParam | None = None,
         temperature: float | None = None,
     ) -> MessageParam:
-        """Create a message using the Anthropic API.
+        """Create a message using a Messages API (provider-agnostic).
 
         Args:
-            messages (list[MessageParam]): The messages to create a message.
+            messages (list[MessageParam]): The message history.
             model_id (str): The model identifier to use.
-            tools (ToolCollection | None): The tools to use.
+            tools (ToolCollection | None): The tools available to the model.
             max_tokens (int | None): The maximum number of tokens to generate.
-            betas (list[str] | None): The betas to use.
-            system (SystemPrompt | None): The system to use.
-            thinking (dict[str, str] | None): The thinking to use.
-            tool_choice (dict[str, str] | None): The tool choice to use.
-            temperature (float | None): The temperature to use.
+            betas (list[str] | None): Beta features to enable (provider-specific).
+            system (SystemPrompt | None): The system prompt.
+            thinking (ThinkingConfigParam | None): Thinking configuration (provider-specific).
+            tool_choice (ToolChoiceParam | None): Tool choice configuration (provider-specific).
+            temperature (float | None): The sampling temperature (0-1).
 
         Returns:
-            MessageParam: The created message.
+            MessageParam: The created message from the model.
+
+        Note:
+            The `thinking` and `tool_choice` parameters are provider-specific
+            dictionaries. See the specific MessagesApi implementation for details.
+            For Anthropic: see anthropic.types.beta.BetaThinkingConfigParam and
+            BetaToolChoiceParam.
         """
         raise NotImplementedError
diff --git a/src/askui/models/shared/settings.py b/src/askui/models/shared/settings.py
@@ -1,12 +1,7 @@
-from anthropic import Omit, omit
-from anthropic.types import AnthropicBetaParam
-from anthropic.types.beta import (
-    BetaThinkingConfigParam,
-    BetaToolChoiceParam,
-)
 from pydantic import BaseModel, ConfigDict, Field
 from typing_extensions import Literal
 
+from askui.models.shared.agent_message_param import ThinkingConfigParam, ToolChoiceParam
 from askui.models.shared.prompts import (
     ActSystemPrompt,
     GetSystemPrompt,
@@ -20,14 +15,21 @@
 
 
 class MessageSettings(BaseModel):
+    """Settings for message creation in ActModel operations.
+
+    The `thinking` and `tool_choice` fields are provider-specific dictionaries.
+    For Anthropic models, see: anthropic.types.beta.BetaThinkingConfigParam
+    and anthropic.types.beta.BetaToolChoiceParam
+    """
+
     model_config = ConfigDict(arbitrary_types_allowed=True)
 
-    betas: list[AnthropicBetaParam] | Omit = omit
+    betas: list[str] | None = None
     max_tokens: int = 8192
     system: ActSystemPrompt | None = None
-    thinking: BetaThinkingConfigParam | Omit = omit
-    tool_choice: BetaToolChoiceParam | Omit = omit
-    temperature: float | Omit = Field(default=omit, ge=0.0, le=1.0)
+    thinking: ThinkingConfigParam | None = None
+    tool_choice: ToolChoiceParam | None = None
+    temperature: float | None = Field(default=None, ge=0.0, le=1.0)
 
 
 class ActSettings(BaseModel):
diff --git a/src/askui/models/shared/token_counter.py b/src/askui/models/shared/token_counter.py
@@ -3,14 +3,14 @@
 from abc import ABC, abstractmethod
 
 import httpx
-from anthropic.types.beta import BetaToolUnionParam
 from typing_extensions import override
 
 from askui.models.shared.agent_message_param import (
     Base64ImageSourceParam,
     ContentBlockParam,
     ImageBlockParam,
     MessageParam,
+    ToolParam,
     ToolResultBlockParam,
 )
 from askui.models.shared.prompts import SystemPrompt
@@ -57,14 +57,14 @@ class TokenCounter(ABC):
     @abstractmethod
     def count_tokens(
         self,
-        tools: list[BetaToolUnionParam] | None = None,
+        tools: list[ToolParam] | None = None,
         system: ActSystemPrompt | None = None,
         messages: list[MessageParam] | None = None,
     ) -> TokenCounts:
         """Count total tokens (estimated) using simple string length estimation.
 
         Args:
-            tools (list[BetaToolUnionParam] | None, optional): The tools to count
+            tools (list[ToolParam] | None, optional): The tools to count
                 tokens for. Defaults to `None`.
             system (ActSystemPrompt | None, optional): The system
                 prompt or system blocks to count tokens for. Defaults to `None`.
@@ -137,7 +137,7 @@ def _get_image_dimensions_from_url(self, url: str) -> tuple[int, int] | None:
     @override
     def count_tokens(
         self,
-        tools: list[BetaToolUnionParam] | None = None,
+        tools: list[ToolParam] | None = None,
         system: SystemPrompt | None = None,
         messages: list[MessageParam] | None = None,
         model: str | None = None,  # noqa: ARG002
diff --git a/src/askui/models/shared/tools.py b/src/askui/models/shared/tools.py
@@ -7,12 +7,6 @@
 
 import jsonref
 import mcp
-from anthropic.types.beta import (
-    BetaCacheControlEphemeralParam,
-    BetaToolParam,
-    BetaToolUnionParam,
-)
-from anthropic.types.beta.beta_tool_param import InputSchema
 from asyncer import syncify
 from fastmcp.client.client import CallToolResult, ProgressHandler
 from fastmcp.tools import Tool as FastMcpTool
@@ -24,9 +18,11 @@
 
 from askui.models.shared.agent_message_param import (
     Base64ImageSourceParam,
+    CacheControlEphemeralParam,
     ContentBlockParam,
     ImageBlockParam,
     TextBlockParam,
+    ToolParam,
     ToolResultBlockParam,
     ToolUseBlockParam,
 )
@@ -109,7 +105,7 @@ def _convert_to_content(
     ]
 
 
-def _default_input_schema() -> InputSchema:
+def _default_input_schema() -> dict[str, Any]:
     return {"type": "object", "properties": {}, "required": []}
 
 
@@ -163,7 +159,7 @@ def _create_tool_result_block_param_for_playwright_error(
 class Tool(BaseModel, ABC):
     name: str = Field(description="Name of the tool")
     description: str = Field(description="Description of what the tool does")
-    input_schema: InputSchema = Field(
+    input_schema: dict[str, Any] = Field(
         default_factory=_default_input_schema,
         description="JSON schema for tool parameters",
     )
@@ -179,8 +175,8 @@ def __call__(self, *args: Any, **kwargs: Any) -> ToolCallResult:
 
     def to_params(
         self,
-    ) -> BetaToolUnionParam:
-        return BetaToolParam(
+    ) -> ToolParam:
+        return ToolParam(
             name=self.name,
             description=self.description,
             input_schema=self.input_schema,
@@ -277,7 +273,7 @@ async def __aexit__(
     ) -> None: ...
 
 
-def _replace_refs(tool_name: str, input_schema: InputSchema) -> InputSchema:
+def _replace_refs(tool_name: str, input_schema: dict[str, Any]) -> dict[str, Any]:
     try:
         return jsonref.replace_refs(  # type: ignore[no-any-return]
             input_schema,
@@ -352,7 +348,7 @@ def retrieve_tool_beta_flags(self) -> list[str]:
                 result.add(beta_flag)
         return list(result)
 
-    def to_params(self) -> list[BetaToolUnionParam]:
+    def to_params(self) -> list[ToolParam]:
         tool_map = {
             **self._get_mcp_tool_params(),
             **{
@@ -366,22 +362,22 @@ def to_params(self) -> list[BetaToolUnionParam]:
         }
         result = list(filtered_tool_map.values())
         if result:
-            result[-1]["cache_control"] = BetaCacheControlEphemeralParam(
+            result[-1]["cache_control"] = CacheControlEphemeralParam(
                 type="ephemeral",
             )
         return result
 
-    def _get_mcp_tool_params(self) -> dict[str, BetaToolUnionParam]:
+    def _get_mcp_tool_params(self) -> dict[str, ToolParam]:
         if not self._mcp_client:
             return {}
         mcp_tools = self._get_mcp_tools()
-        result: dict[str, BetaToolUnionParam] = {}
+        result: dict[str, ToolParam] = {}
         for tool_name, tool in mcp_tools.items():
             if params := (tool.meta or {}).get("params"):
                 # validation missing
                 result[tool_name] = params
                 continue
-            result[tool_name] = BetaToolParam(
+            result[tool_name] = ToolParam(
                 name=tool_name,
                 description=tool.description or "",
                 input_schema=_replace_refs(tool_name, tool.inputSchema),
diff --git a/src/askui/models/shared/truncation_strategies.py b/src/askui/models/shared/truncation_strategies.py
