feat: add configurable Anthropic-compatible LLM support

Author: Desmond-Dong

custom_components/ai_hub/config_flow.py

@@ -39,6 +39,7 @@
     AI_HUB_IMAGE_MODELS,
     CONF_CHAT_MODEL,
     CONF_CHAT_URL,
+    CONF_LLM_PROVIDER,
     CONF_CUSTOM_API_KEY,
     CONF_FORCE_TRANSLATION,
     CONF_IMAGE_MODEL,
@@ -69,6 +70,7 @@
     RECOMMENDED_AI_TASK_OPTIONS,
     RECOMMENDED_AI_TASK_TEMPERATURE,
     RECOMMENDED_CHAT_MODEL,
+    RECOMMENDED_LLM_PROVIDER,
     RECOMMENDED_CONVERSATION_OPTIONS,
     RECOMMENDED_IMAGE_MODEL,
     RECOMMENDED_MAX_HISTORY_MESSAGES,
@@ -379,6 +381,16 @@ async def ai_hub_config_option_schema(
                 default=options.get(CONF_PROMPT, llm.DEFAULT_INSTRUCTIONS_PROMPT),
                 description={"suggested_value": options.get(CONF_PROMPT)},
             ): TemplateSelector(),
+            vol.Optional(
+                CONF_LLM_PROVIDER,
+                default=options.get(CONF_LLM_PROVIDER, RECOMMENDED_LLM_PROVIDER),
+                description={"suggested_value": options.get(CONF_LLM_PROVIDER)},
+            ): SelectSelector(
+                SelectSelectorConfig(
+                    options=["openai_compatible", "anthropic_compatible"],
+                    mode=SelectSelectorMode.DROPDOWN,
+                )
+            ),
             vol.Optional(
                 CONF_CHAT_MODEL,
                 default=options.get(CONF_CHAT_MODEL, RECOMMENDED_CHAT_MODEL),

custom_components/ai_hub/const.py

@@ -156,6 +156,7 @@ def get_localized_name(hass: HomeAssistant, zh_name: str, en_name: str) -> str:
 # Model Configuration
 CONF_CHAT_MODEL: Final = "chat_model"
 CONF_CHAT_URL: Final = "chat_url"
+CONF_LLM_PROVIDER: Final = "llm_provider"
 CONF_IMAGE_MODEL: Final = "image_model"
 CONF_IMAGE_URL: Final = "image_url"
 CONF_STT_MODEL: Final = "model"
@@ -211,6 +212,7 @@ def get_localized_name(hass: HomeAssistant, zh_name: str, en_name: str) -> str:
 }
 
 RECOMMENDED_CHAT_MODEL: Final = RECOMMENDED["chat_model"]
+RECOMMENDED_LLM_PROVIDER: Final = "openai_compatible"
 RECOMMENDED_TEMPERATURE: Final = RECOMMENDED["temperature"]
 RECOMMENDED_TOP_P: Final = RECOMMENDED["top_p"]
 RECOMMENDED_TOP_K: Final = RECOMMENDED["top_k"]
@@ -393,6 +395,7 @@ def get_localized_name(hass: HomeAssistant, zh_name: str, en_name: str) -> str:
     CONF_RECOMMENDED: True,
     CONF_LLM_HASS_API: LLM_API_ASSIST,
     CONF_PROMPT: DEFAULT_INSTRUCTIONS_PROMPT,
+    CONF_LLM_PROVIDER: RECOMMENDED_LLM_PROVIDER,
     CONF_CHAT_MODEL: RECOMMENDED_CHAT_MODEL,
     CONF_CHAT_URL: AI_HUB_CHAT_URL,
     CONF_TEMPERATURE: RECOMMENDED_TEMPERATURE,

custom_components/ai_hub/entity.py

@@ -19,10 +19,12 @@
 from homeassistant.util import ulid
 from voluptuous_openapi import convert
 
+from .providers import LLMMessage, create_provider
 from .const import (
     AI_HUB_CHAT_URL,
     CONF_CHAT_MODEL,
     CONF_CHAT_URL,
+    CONF_LLM_PROVIDER,
     CONF_CUSTOM_API_KEY,
     CONF_MAX_HISTORY_MESSAGES,
     CONF_MAX_TOKENS,
@@ -76,6 +78,17 @@ def _get_request_ssl_setting(api_url: str, default_url: str) -> bool | None:
     return None
 
 
+def _get_provider_name(api_url: str, configured_provider: str | None = None) -> str:
+    """Select provider implementation from URL."""
+    if configured_provider in {"openai_compatible", "anthropic_compatible"}:
+        return configured_provider
+
+    parsed = urlparse(api_url)
+    if "anthropic" in parsed.path.lower() or parsed.netloc == "api.anthropic.com":
+        return "anthropic_compatible"
+    return "openai_compatible"
+
+
 class _AIHubEntityMixin:
     """Mixin class providing common initialization logic for AI Hub entities.
 
@@ -283,15 +296,6 @@ async def _async_handle_chat_log(
             model_name = self.default_model
             _LOGGER.warning("Model name was invalid, using default: %s", model_name)
 
-        request_params = {
-            "model": model_name,
-            "messages": messages,
-            "stream": True,
-        }
-
-        if tools:
-            request_params["tools"] = tools
-
         # Validate all message contents before sending
         for i, msg in enumerate(messages):
             msg_content = msg.get("content")
@@ -311,6 +315,17 @@ async def _async_handle_chat_log(
             api_url = AI_HUB_CHAT_URL
             _LOGGER.warning("API URL was invalid, using default: %s", api_url)
 
+        provider_name = _get_provider_name(api_url, options.get(CONF_LLM_PROVIDER))
+
+        request_params = {
+            "model": model_name,
+            "messages": messages,
+            "stream": True,
+        }
+
+        if tools:
+            request_params["tools"] = tools
+
         try:
             # Validate API key before making request
             if not self._api_key:
@@ -322,11 +337,46 @@ async def _async_handle_chat_log(
                 self._api_key = str(self._api_key)
 
             _LOGGER.debug(
-                "API Request: model=%s, messages_count=%d",
+                "API Request: provider=%s, model=%s, messages_count=%d",
+                provider_name,
                 model_name,
                 len(messages)
             )
 
+            llm_messages = [
+                LLMMessage(
+                    role=msg["role"],
+                    content=msg.get("content", ""),
+                    tool_calls=msg.get("tool_calls"),
+                    tool_call_id=msg.get("tool_call_id"),
+                )
+                for msg in messages
+            ]
+
+            provider = create_provider(
+                provider_name,
+                {
+                    "api_key": self._api_key,
+                    "model": model_name,
+                    "base_url": api_url,
+                    "temperature": model_config.get("temperature", RECOMMENDED_TEMPERATURE),
+                    "max_tokens": model_config.get("max_tokens", RECOMMENDED_MAX_TOKENS),
+                },
+            )
+
+            if provider_name == "anthropic_compatible" and provider is not None:
+                response = await provider.complete(llm_messages, tools=tools)
+                tool_calls = self._convert_provider_tool_calls(response.tool_calls)
+                assistant_content = conversation.AssistantContent(
+                    agent_id=self.entity_id,
+                    content=response.content or None,
+                    tool_calls=tool_calls or None,
+                    native=response.raw_response,
+                )
+                async for _ in chat_log.async_add_assistant_content(assistant_content):
+                    pass
+                return
+
             # Call AI Hub API with streaming via HTTP
             headers = {
                 "Authorization": f"Bearer {self._api_key}",
@@ -363,6 +413,37 @@ async def _async_handle_chat_log(
             _LOGGER.error("Error calling AI Hub API: %s", err)
             raise HomeAssistantError(ERROR_GETTING_RESPONSE) from err
 
+    def _convert_provider_tool_calls(
+        self,
+        tool_calls: list[dict[str, Any]] | None,
+    ) -> list[llm.ToolInput]:
+        """Convert provider tool calls to Home Assistant ToolInput objects."""
+        if not tool_calls:
+            return []
+
+        converted: list[llm.ToolInput] = []
+        for tool_call in tool_calls:
+            try:
+                function_data = tool_call.get("function", {})
+                arguments = function_data.get("arguments", {})
+                if isinstance(arguments, str):
+                    arguments = json.loads(arguments) if arguments else {}
+                if not isinstance(arguments, dict):
+                    arguments = {"value": arguments}
+
+                tool_id = tool_call.get("id") or ulid.ulid_now()
+                converted.append(
+                    llm.ToolInput(
+                        id=tool_id,
+                        tool_name=function_data.get("name", "tool"),
+                        tool_args=arguments,
+                    )
+                )
+            except Exception as err:
+                _LOGGER.warning("Failed to convert provider tool call: %s", err)
+
+        return converted
+
     async def _async_convert_chat_log_to_messages(
         self, chat_log: conversation.ChatLog
     ) -> list[dict[str, Any]]:

custom_components/ai_hub/manifest.json

@@ -9,5 +9,5 @@
   "iot_class": "cloud_polling",
   "issue_tracker": "https://github.com/ha-china/ai_hub/issues",
   "requirements": ["edge-tts==7.2.7", "aiofiles", "aiohttp"],
-  "version": "v2026.3.6"
+  "version": "v2026.04.0"
 }

custom_components/ai_hub/providers/anthropic_compatible.py

@@ -50,10 +50,22 @@ def _get_headers(self) -> dict[str, str]:
         }
         if self.config.api_key:
             headers["x-api-key"] = self.config.api_key
+            headers["Authorization"] = f"Bearer {self.config.api_key}"
         return headers
 
     def _get_api_url(self) -> str:
-        return self.config.base_url or _DEFAULT_API_URL
+        url = self.config.base_url or _DEFAULT_API_URL
+        if not url:
+            return _DEFAULT_API_URL
+
+        normalized = url.rstrip("/")
+        if normalized.endswith("/v1/messages"):
+            return normalized
+        if normalized.endswith("/messages"):
+            return normalized
+        if normalized.endswith("/v1"):
+            return f"{normalized}/messages"
+        return f"{normalized}/v1/messages"
 
     def _convert_content_blocks(self, content: str | list[dict[str, Any]]) -> str | list[dict[str, Any]]:
         if isinstance(content, str):
@@ -140,6 +152,74 @@ def _convert_tools(self, tools: list[dict[str, Any]] | None) -> list[dict[str, A
     def _extract_text(self, content_blocks: list[dict[str, Any]]) -> str:
         return "".join(block.get("text", "") for block in content_blocks if block.get("type") == "text")
 
+    def _extract_response_text(self, data: dict[str, Any]) -> str:
+        """Extract text from Anthropic-compatible responses.
+
+        Some third-party compatible endpoints do not return the exact official
+        Anthropic payload shape, so we accept a few common variants.
+        """
+        content = data.get("content", [])
+        if isinstance(content, str):
+            return content
+        if isinstance(content, list):
+            text = self._extract_text(content)
+            if text:
+                return text
+
+        if isinstance(data.get("output_text"), str):
+            return data["output_text"]
+        if isinstance(data.get("text"), str):
+            return data["text"]
+
+        message = data.get("message")
+        if isinstance(message, dict):
+            if isinstance(message.get("content"), str):
+                return message["content"]
+            if isinstance(message.get("content"), list):
+                text = self._extract_text(message["content"])
+                if text:
+                    return text
+
+        choices = data.get("choices")
+        if isinstance(choices, list) and choices:
+            first = choices[0]
+            if isinstance(first, dict):
+                if isinstance(first.get("text"), str):
+                    return first["text"]
+                message = first.get("message")
+                if isinstance(message, dict) and isinstance(message.get("content"), str):
+                    return message["content"]
+
+        return ""
+
+    def _extract_response_tool_calls(self, data: dict[str, Any]) -> list[dict[str, Any]] | None:
+        """Extract tool calls from Anthropic-compatible responses."""
+        content = data.get("content", [])
+        if isinstance(content, list):
+            tool_calls = self._extract_tool_calls(content)
+            if tool_calls:
+                return tool_calls
+
+        message = data.get("message")
+        if isinstance(message, dict):
+            content = message.get("content")
+            if isinstance(content, list):
+                tool_calls = self._extract_tool_calls(content)
+                if tool_calls:
+                    return tool_calls
+
+        choices = data.get("choices")
+        if isinstance(choices, list) and choices:
+            first = choices[0]
+            if isinstance(first, dict):
+                message = first.get("message")
+                if isinstance(message, dict):
+                    tool_calls = message.get("tool_calls")
+                    if isinstance(tool_calls, list):
+                        return tool_calls
+
+        return None
+
     def _extract_tool_calls(self, content_blocks: list[dict[str, Any]]) -> list[dict[str, Any]] | None:
         tool_calls = []
         for block in content_blocks:
@@ -212,9 +292,14 @@ async def complete(
                 "output_tokens": usage.get("output_tokens", 0),
             }
 
+        text_content = self._extract_response_text(data)
+        tool_calls = self._extract_response_tool_calls(data)
+        if not text_content and not tool_calls:
+            _LOGGER.debug("Anthropic-compatible empty response payload: %s", data)
+
         return LLMResponse(
-            content=self._extract_text(content_blocks),
-            tool_calls=self._extract_tool_calls(content_blocks),
+            content=text_content,
+            tool_calls=tool_calls,
             usage=usage,
             model=data.get("model"),
             finish_reason=data.get("stop_reason"),

custom_components/ai_hub/strings.json

@@ -46,6 +46,7 @@
             "name": "Name",
             "recommended": "Recommended Mode",
             "prompt": "Prompt Template",
+            "llm_provider": "LLM Provider",
             "chat_model": "Chat Model",
             "temperature": "Temperature",
             "top_p": "Top P",
@@ -56,6 +57,7 @@
           "data_description": {
             "recommended": "Use recommended settings",
             "prompt": "Custom system prompt",
+            "llm_provider": "Select protocol type for the custom LLM endpoint",
             "temperature": "Control creativity (0-2)",
             "top_p": "Sampling parameter (0-1)",
             "max_tokens": "Maximum response length",

custom_components/ai_hub/translations/en.json

@@ -44,6 +44,7 @@
             "name": "Name",
             "recommended": "Recommended Mode",
             "prompt": "Prompt Template",
+            "llm_provider": "LLM Provider",
             "chat_model": "Chat Model",
             "chat_url": "Chat API URL",
             "custom_api_key": "Custom API Key",
@@ -56,6 +57,7 @@
           "data_description": {
             "recommended": "Use recommended settings",
             "prompt": "Custom system prompt",
+            "llm_provider": "Select protocol type for the custom LLM endpoint",
             "chat_model": "Select or enter custom model name",
             "chat_url": "Complete chat API URL (if API fails, try appending /chat/completions)",
             "custom_api_key": "Custom API key (leave empty to use main key)",

custom_components/ai_hub/translations/zh-Hans.json

@@ -44,6 +44,7 @@
             "name": "名称",
             "recommended": "推荐模式",
             "prompt": "提示词模板",
+            "llm_provider": "LLM 协议",
             "chat_model": "聊天模型",
             "chat_url": "对话API地址",
             "custom_api_key": "自定义API密钥",
@@ -56,6 +57,7 @@
           "data_description": {
             "recommended": "使用推荐配置",
             "prompt": "自定义系统提示词",
+            "llm_provider": "选择自定义 LLM 接口使用的协议类型",
             "chat_model": "选择或输入自定义模型名称",
             "chat_url": "完整的对话API地址（如API不通，请在地址后添加 /chat/completions）",
             "custom_api_key": "自定义API密钥（留空使用主密钥）",