Updated apps

custom_components/ai_agent_ha/__init__.py

@@ -0,0 +1,426 @@
+"""The AI Agent HA integration."""
+
+from __future__ import annotations
+
+import logging
+
+import voluptuous as vol
+from homeassistant.components.frontend import async_register_built_in_panel
+from homeassistant.components.http import StaticPathConfig
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryNotReady
+from homeassistant.helpers import config_validation as cv
+from homeassistant.helpers.typing import ConfigType
+
+from .agent import AiAgentHaAgent
+from .const import DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+# Config schema - this integration only supports config entries
+CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+
+# Define service schema to accept a custom prompt
+SERVICE_SCHEMA = vol.Schema(
+    {
+        vol.Optional("prompt"): cv.string,
+    }
+)
+
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the AI Agent HA component."""
+    return True
+
+
+async def async_migrate_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Migrate old config entries to new version."""
+    _LOGGER.debug("Migrating config entry from version %s", entry.version)
+
+    if entry.version == 1:
+        # No migration needed for version 1
+        return True
+
+    # Future migrations would go here
+    # if entry.version < 2:
+    #     # Migrate from version 1 to 2
+    #     new_data = dict(entry.data)
+    #     # Add migration logic here
+    #     hass.config_entries.async_update_entry(entry, data=new_data, version=2)
+
+    _LOGGER.info("Migration to version %s successful", entry.version)
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Set up AI Agent HA from a config entry."""
+    try:
+        # Handle version compatibility
+        if not hasattr(entry, "version") or entry.version != 1:
+            _LOGGER.warning(
+                "Config entry has version %s, expected 1. Attempting compatibility mode.",
+                getattr(entry, "version", "unknown"),
+            )
+
+        # Convert ConfigEntry to dict and ensure all required keys exist
+        config_data = dict(entry.data)
+
+        # Ensure backward compatibility - check for required keys
+        if "ai_provider" not in config_data:
+            _LOGGER.error(
+                "Config entry missing required 'ai_provider' key. Entry data: %s",
+                config_data,
+            )
+            raise ConfigEntryNotReady("Config entry missing required 'ai_provider' key")
+
+        if DOMAIN not in hass.data:
+            hass.data[DOMAIN] = {"agents": {}, "configs": {}}
+
+        provider = config_data["ai_provider"]
+
+        # Validate provider
+        if provider not in [
+            "llama",
+            "openai",
+            "gemini",
+            "openrouter",
+            "anthropic",
+            "alter",
+            "zai",
+            "local_ollama",
+            "openai_compatible",
+        ]:
+            _LOGGER.error("Unknown AI provider: %s", provider)
+            raise ConfigEntryNotReady(f"Unknown AI provider: {provider}")
+
+        # Store config for this provider
+        hass.data[DOMAIN]["configs"][provider] = config_data
+
+        # Create agent for this provider
+        _LOGGER.debug(
+            "Creating AI agent for provider %s with config: %s",
+            provider,
+            {
+                k: v
+                for k, v in config_data.items()
+                if k
+                not in [
+                    "llama_token",
+                    "openai_token",
+                    "gemini_token",
+                    "openrouter_token",
+                    "anthropic_token",
+                    "zai_token",
+                ]
+            },
+        )
+        hass.data[DOMAIN]["agents"][provider] = AiAgentHaAgent(hass, config_data)
+
+        _LOGGER.info("Successfully set up AI Agent HA for provider: %s", provider)
+
+    except KeyError as err:
+        _LOGGER.error("Missing required configuration key: %s", err)
+        raise ConfigEntryNotReady(f"Missing required configuration key: {err}")
+    except Exception as err:
+        _LOGGER.exception("Unexpected error setting up AI Agent HA")
+        raise ConfigEntryNotReady(f"Error setting up AI Agent HA: {err}")
+
+    # Modify the query service handler to use the correct provider
+    async def async_handle_query(call):
+        """Handle the query service call."""
+        try:
+            # Check if agents are available
+            if DOMAIN not in hass.data or not hass.data[DOMAIN].get("agents"):
+                _LOGGER.error(
+                    "No AI agents available. Please configure the integration first."
+                )
+                result = {"error": "No AI agents configured"}
+                hass.bus.async_fire("ai_agent_ha_response", result)
+                return
+
+            provider = call.data.get("provider")
+            if provider not in hass.data[DOMAIN]["agents"]:
+                # Get the first available provider
+                available_providers = list(hass.data[DOMAIN]["agents"].keys())
+                if not available_providers:
+                    _LOGGER.error("No AI agents available")
+                    result = {"error": "No AI agents configured"}
+                    hass.bus.async_fire("ai_agent_ha_response", result)
+                    return
+                provider = available_providers[0]
+                _LOGGER.debug(f"Using fallback provider: {provider}")
+
+            agent = hass.data[DOMAIN]["agents"][provider]
+            result = await agent.process_query(
+                call.data.get("prompt", ""),
+                provider=provider,
+                debug=call.data.get("debug", False),
+            )
+            hass.bus.async_fire("ai_agent_ha_response", result)
+        except Exception as e:
+            _LOGGER.error(f"Error processing query: {e}")
+            result = {"error": str(e)}
+            hass.bus.async_fire("ai_agent_ha_response", result)
+
+    async def async_handle_create_automation(call):
+        """Handle the create_automation service call."""
+        try:
+            # Check if agents are available
+            if DOMAIN not in hass.data or not hass.data[DOMAIN].get("agents"):
+                _LOGGER.error(
+                    "No AI agents available. Please configure the integration first."
+                )
+                return {"error": "No AI agents configured"}
+
+            provider = call.data.get("provider")
+            if provider not in hass.data[DOMAIN]["agents"]:
+                # Get the first available provider
+                available_providers = list(hass.data[DOMAIN]["agents"].keys())
+                if not available_providers:
+                    _LOGGER.error("No AI agents available")
+                    return {"error": "No AI agents configured"}
+                provider = available_providers[0]
+                _LOGGER.debug(f"Using fallback provider: {provider}")
+
+            agent = hass.data[DOMAIN]["agents"][provider]
+            result = await agent.create_automation(call.data.get("automation", {}))
+            return result
+        except Exception as e:
+            _LOGGER.error(f"Error creating automation: {e}")
+            return {"error": str(e)}
+
+    async def async_handle_save_prompt_history(call):
+        """Handle the save_prompt_history service call."""
+        try:
+            # Check if agents are available
+            if DOMAIN not in hass.data or not hass.data[DOMAIN].get("agents"):
+                _LOGGER.error(
+                    "No AI agents available. Please configure the integration first."
+                )
+                return {"error": "No AI agents configured"}
+
+            provider = call.data.get("provider")
+            if provider not in hass.data[DOMAIN]["agents"]:
+                # Get the first available provider
+                available_providers = list(hass.data[DOMAIN]["agents"].keys())
+                if not available_providers:
+                    _LOGGER.error("No AI agents available")
+                    return {"error": "No AI agents configured"}
+                provider = available_providers[0]
+                _LOGGER.debug(f"Using fallback provider: {provider}")
+
+            agent = hass.data[DOMAIN]["agents"][provider]
+            user_id = call.context.user_id if call.context.user_id else "default"
+            result = await agent.save_user_prompt_history(
+                user_id, call.data.get("history", [])
+            )
+            return result
+        except Exception as e:
+            _LOGGER.error(f"Error saving prompt history: {e}")
+            return {"error": str(e)}
+
+    async def async_handle_load_prompt_history(call):
+        """Handle the load_prompt_history service call."""
+        try:
+            # Check if agents are available
+            if DOMAIN not in hass.data or not hass.data[DOMAIN].get("agents"):
+                _LOGGER.error(
+                    "No AI agents available. Please configure the integration first."
+                )
+                return {"error": "No AI agents configured"}
+
+            provider = call.data.get("provider")
+            if provider not in hass.data[DOMAIN]["agents"]:
+                # Get the first available provider
+                available_providers = list(hass.data[DOMAIN]["agents"].keys())
+                if not available_providers:
+                    _LOGGER.error("No AI agents available")
+                    return {"error": "No AI agents configured"}
+                provider = available_providers[0]
+                _LOGGER.debug(f"Using fallback provider: {provider}")
+
+            agent = hass.data[DOMAIN]["agents"][provider]
+            user_id = call.context.user_id if call.context.user_id else "default"
+            result = await agent.load_user_prompt_history(user_id)
+            _LOGGER.debug("Load prompt history result: %s", result)
+            return result
+        except Exception as e:
+            _LOGGER.error(f"Error loading prompt history: {e}")
+            return {"error": str(e)}
+
+    async def async_handle_create_dashboard(call):
+        """Handle the create_dashboard service call."""
+        try:
+            # Check if agents are available
+            if DOMAIN not in hass.data or not hass.data[DOMAIN].get("agents"):
+                _LOGGER.error(
+                    "No AI agents available. Please configure the integration first."
+                )
+                return {"error": "No AI agents configured"}
+
+            provider = call.data.get("provider")
+            if provider not in hass.data[DOMAIN]["agents"]:
+                # Get the first available provider
+                available_providers = list(hass.data[DOMAIN]["agents"].keys())
+                if not available_providers:
+                    _LOGGER.error("No AI agents available")
+                    return {"error": "No AI agents configured"}
+                provider = available_providers[0]
+                _LOGGER.debug(f"Using fallback provider: {provider}")
+
+            agent = hass.data[DOMAIN]["agents"][provider]
+
+            # Parse dashboard config if it's a string
+            dashboard_config = call.data.get("dashboard_config", {})
+            if isinstance(dashboard_config, str):
+                try:
+                    import json
+
+                    dashboard_config = json.loads(dashboard_config)
+                except json.JSONDecodeError as e:
+                    _LOGGER.error(f"Invalid JSON in dashboard_config: {e}")
+                    return {"error": f"Invalid JSON in dashboard_config: {e}"}
+
+            result = await agent.create_dashboard(dashboard_config)
+            return result
+        except Exception as e:
+            _LOGGER.error(f"Error creating dashboard: {e}")
+            return {"error": str(e)}
+
+    async def async_handle_update_dashboard(call):
+        """Handle the update_dashboard service call."""
+        try:
+            # Check if agents are available
+            if DOMAIN not in hass.data or not hass.data[DOMAIN].get("agents"):
+                _LOGGER.error(
+                    "No AI agents available. Please configure the integration first."
+                )
+                return {"error": "No AI agents configured"}
+
+            provider = call.data.get("provider")
+            if provider not in hass.data[DOMAIN]["agents"]:
+                # Get the first available provider
+                available_providers = list(hass.data[DOMAIN]["agents"].keys())
+                if not available_providers:
+                    _LOGGER.error("No AI agents available")
+                    return {"error": "No AI agents configured"}
+                provider = available_providers[0]
+                _LOGGER.debug(f"Using fallback provider: {provider}")
+
+            agent = hass.data[DOMAIN]["agents"][provider]
+
+            # Parse dashboard config if it's a string
+            dashboard_config = call.data.get("dashboard_config", {})
+            if isinstance(dashboard_config, str):
+                try:
+                    import json
+
+                    dashboard_config = json.loads(dashboard_config)
+                except json.JSONDecodeError as e:
+                    _LOGGER.error(f"Invalid JSON in dashboard_config: {e}")
+                    return {"error": f"Invalid JSON in dashboard_config: {e}"}
+
+            dashboard_url = call.data.get("dashboard_url", "")
+            if not dashboard_url:
+                return {"error": "Dashboard URL is required"}
+
+            result = await agent.update_dashboard(dashboard_url, dashboard_config)
+            return result
+        except Exception as e:
+            _LOGGER.error(f"Error updating dashboard: {e}")
+            return {"error": str(e)}
+
+    # Register services
+    hass.services.async_register(DOMAIN, "query", async_handle_query)
+    hass.services.async_register(
+        DOMAIN, "create_automation", async_handle_create_automation
+    )
+    hass.services.async_register(
+        DOMAIN, "save_prompt_history", async_handle_save_prompt_history
+    )
+    hass.services.async_register(
+        DOMAIN, "load_prompt_history", async_handle_load_prompt_history
+    )
+    hass.services.async_register(
+        DOMAIN, "create_dashboard", async_handle_create_dashboard
+    )
+    hass.services.async_register(
+        DOMAIN, "update_dashboard", async_handle_update_dashboard
+    )
+
+    # Register static path for frontend
+    await hass.http.async_register_static_paths(
+        [
+            StaticPathConfig(
+                "/frontend/ai_agent_ha",
+                hass.config.path("custom_components/ai_agent_ha/frontend"),
+                False,
+            )
+        ]
+    )
+
+    # Panel registration with proper error handling
+    panel_name = "ai_agent_ha"
+    try:
+        if await _panel_exists(hass, panel_name):
+            _LOGGER.debug("AI Agent HA panel already exists, skipping registration")
+            return True
+
+        _LOGGER.debug("Registering AI Agent HA panel")
+        async_register_built_in_panel(
+            hass,
+            component_name="custom",
+            sidebar_title="AI Agent HA",
+            sidebar_icon="mdi:robot",
+            frontend_url_path=panel_name,
+            require_admin=False,
+            config={
+                "_panel_custom": {
+                    "name": "ai_agent_ha-panel",
+                    "module_url": "/frontend/ai_agent_ha/ai_agent_ha-panel.js",
+                    "embed_iframe": False,
+                }
+            },
+        )
+        _LOGGER.debug("AI Agent HA panel registered successfully")
+    except Exception as e:
+        _LOGGER.warning("Panel registration error: %s", str(e))
+
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Unload a config entry."""
+    if await _panel_exists(hass, "ai_agent_ha"):
+        try:
+            from homeassistant.components.frontend import async_remove_panel
+
+            async_remove_panel(hass, "ai_agent_ha")
+            _LOGGER.debug("AI Agent HA panel removed successfully")
+        except Exception as e:
+            _LOGGER.debug("Error removing panel: %s", str(e))
+
+    # Remove services
+    hass.services.async_remove(DOMAIN, "query")
+    hass.services.async_remove(DOMAIN, "create_automation")
+    hass.services.async_remove(DOMAIN, "save_prompt_history")
+    hass.services.async_remove(DOMAIN, "load_prompt_history")
+    hass.services.async_remove(DOMAIN, "create_dashboard")
+    hass.services.async_remove(DOMAIN, "update_dashboard")
+    # Remove data
+    if DOMAIN in hass.data:
+        hass.data.pop(DOMAIN)
+
+    return True
+
+
+async def _panel_exists(hass: HomeAssistant, panel_name: str) -> bool:
+    """Check if a panel already exists."""
+    try:
+        return hasattr(hass.data, "frontend_panels") and panel_name in hass.data.get(
+            "frontend_panels", {}
+        )
+    except Exception as e:
+        _LOGGER.debug("Error checking panel existence: %s", str(e))
+        return False

custom_components/ai_agent_ha/config_flow.py

@@ -0,0 +1,917 @@
+"""Config flow for AI Agent HA integration."""
+
+from __future__ import annotations
+
+import logging
+
+import voluptuous as vol
+from homeassistant import config_entries
+from homeassistant.core import callback
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.selector import (
+    SelectSelector,
+    SelectSelectorConfig,
+    TextSelector,
+    TextSelectorConfig,
+)
+
+from .agent import (
+    fetch_gemini_models,
+    fetch_openai_compatible_models,
+    fetch_openai_models,
+)
+from .const import (
+    CONF_LOCAL_OLLAMA_URL,
+    CONF_OPENAI_BASE_URL,
+    CONF_OPENAI_COMPATIBLE_URL,
+    DOMAIN,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+PROVIDERS = {
+    "llama": "Llama",
+    "openai": "OpenAI",
+    "gemini": "Google Gemini",
+    "openrouter": "OpenRouter",
+    "anthropic": "Anthropic (Claude)",
+    "alter": "Alter",
+    "zai": "z.ai",
+    "local_ollama": "Local Ollama",
+    "openai_compatible": "Local OpenAI-Compatible (e.g. LM Studio, vLLM)",
+}
+
+TOKEN_FIELD_NAMES = {
+    "llama": "llama_token",
+    "openai": "openai_token",
+    "gemini": "gemini_token",
+    "openrouter": "openrouter_token",
+    "anthropic": "anthropic_token",
+    "alter": "alter_token",
+    "zai": "zai_token",
+    "zai_endpoint": "zai_endpoint",
+    "local_ollama": CONF_LOCAL_OLLAMA_URL,  # For local Ollama models, we use URL instead of token
+    "openai_compatible": CONF_OPENAI_COMPATIBLE_URL,  # For OpenAI-compatible endpoints
+}
+
+TOKEN_LABELS = {
+    "llama": "Llama API Token",
+    "openai": "OpenAI API Key",
+    "gemini": "Google Gemini API Key",
+    "openrouter": "OpenRouter API Key",
+    "anthropic": "Anthropic API Key",
+    "alter": "Alter API Key",
+    "zai": "z.ai API Key",
+    "zai_endpoint": "z.ai API Endpoint Type",
+    "local_ollama": "Local Ollama API URL (e.g., http://localhost:11434/api/generate)",
+    "openai_compatible": "OpenAI-Compatible URL (e.g., http://example.com/v1/ or http://localhost:8080/v1/). Must end with /v1/",
+}
+
+DEFAULT_MODELS = {
+    "llama": "Llama-4-Maverick-17B-128E-Instruct-FP8",
+    "openai": "gpt-5",
+    "gemini": "gemini-2.5-flash",
+    "openrouter": "openai/gpt-4o",
+    "anthropic": "claude-sonnet-4-5-20250929",
+    "alter": "",  # User enters custom model
+    "zai": "glm-4.7",  # Z.ai's latest flagship model
+    "local_ollama": "llama3.2",  # Updated to use llama3.2 as default for local Ollama
+    "openai_compatible": "",  # User enters custom model for OpenAI-compatible endpoint
+}
+
+AVAILABLE_MODELS = {
+    "openai": [
+        "gpt-5",
+        "gpt-5-mini",
+        "gpt-5-nano",
+        "gpt-4.1",
+        "gpt-4.1-mini",
+        "gpt-4.1-nano",
+        "gpt-4o",
+        "gpt-4o-mini",
+        "o3",
+        "o3-mini",
+        "o4-mini",
+        "o1",
+        "o1-preview",
+        "o1-mini",
+        "gpt-4-turbo",
+        "gpt-4",
+        "gpt-3.5-turbo",
+    ],
+    "gemini": [
+        "gemini-2.5-flash",
+        "gemini-2.5-pro",
+        "gemini-2.0-flash",
+        "gemini-2.0-flash-exp",
+        "gemini-2.5-flash-preview",
+        "gemini-2.5-pro-preview",
+    ],
+    "openrouter": [
+        "openai/gpt-4o",
+        "openai/gpt-4-turbo",
+        "openai/gpt-3.5-turbo",
+        "anthropic/claude-3.5-sonnet",
+        "anthropic/claude-3-sonnet",
+        "anthropic/claude-3-haiku",
+        "meta-llama/llama-3.1-70b-instruct",
+        "meta-llama/llama-3.2-90b-instruct",
+        "google/gemini-pro",
+        "mistralai/mixtral-8x7b-instruct",
+        "deepseek/deepseek-r1",
+    ],
+    "anthropic": [
+        "claude-opus-4-7",
+        "claude-sonnet-4-6",
+        "claude-haiku-4-5",
+        "claude-sonnet-4-5-20250929",
+        "claude-sonnet-4-20250514",
+        "claude-3-5-sonnet-20241022",
+        "claude-3-5-haiku-20241022",
+        "claude-3-opus-20240229",
+        "claude-3-sonnet-20240229",
+        "claude-3-haiku-20240307",
+    ],
+    "llama": [
+        "Llama-4-Maverick-17B-128E-Instruct-FP8",
+        "Llama-3.1-70B-Instruct",
+        "Llama-3.1-8B-Instruct",
+        "Llama-3.2-90B-Instruct",
+    ],
+    # Alter - user enters custom model name only
+    "alter": [
+        "Custom...",
+    ],
+    # z.ai - available models
+    "zai": [
+        "glm-4.7",
+        "glm-4.6",
+        "glm-4.5",
+        "glm-4.5-air",
+        "glm-4.5-x",
+        "glm-4.5-airx",
+        "glm-4.5-flash",
+        "glm-4-32b-0414-128k",
+        "Custom...",
+    ],
+    # For local Ollama models, provide common models with llama3.2 as the default
+    "local_ollama": [
+        "llama3.2",
+        "llama3",
+        "llama3.1",
+        "mistral",
+        "mixtral",
+        "deepseek-coder",
+        "Custom...",
+    ],
+    # For OpenAI-compatible endpoints, user should specify their model
+    "openai_compatible": [
+        "Custom...",
+    ],
+}
+
+DEFAULT_PROVIDER = "openai"
+
+
+class AiAgentHaConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):  # type: ignore[call-arg,misc]
+    """Handle a config flow for AI Agent HA."""
+
+    VERSION = 1
+    CONNECTION_CLASS = config_entries.CONN_CLASS_CLOUD_POLL
+
+    @staticmethod
+    @callback
+    def async_get_options_flow(config_entry):
+        """Get the options flow for this handler."""
+        try:
+            return AiAgentHaOptionsFlowHandler()
+        except Exception as e:
+            _LOGGER.error("Error creating options flow: %s", e)
+            return None
+
+    async def async_step_user(self, user_input=None):
+        """Handle the initial step."""
+        errors = {}
+
+        if user_input is not None:
+            # Check if this provider is already configured
+            await self.async_set_unique_id(f"ai_agent_ha_{user_input['ai_provider']}")
+            self._abort_if_unique_id_configured()
+
+            self.config_data = {"ai_provider": user_input["ai_provider"]}
+            return await self.async_step_configure()
+
+        # Show provider selection form
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required("ai_provider"): SelectSelector(
+                        SelectSelectorConfig(
+                            options=[
+                                {"value": k, "label": v} for k, v in PROVIDERS.items()
+                            ]
+                        )
+                    ),
+                }
+            ),
+        )
+
+    async def async_step_configure(self, user_input=None):
+        """Handle the configuration step for the selected provider."""
+        errors = {}
+        provider = self.config_data["ai_provider"]
+        token_field = TOKEN_FIELD_NAMES[provider]
+        token_label = TOKEN_LABELS[provider]
+        default_model = DEFAULT_MODELS[provider]
+        # For Alter provider, default to "Custom..." for the dropdown since model is user-provided
+        dropdown_default = "Custom..." if provider == "alter" else default_model
+        available_models = AVAILABLE_MODELS.get(provider, [default_model])
+
+        if user_input is not None:
+            try:
+                # Validate the token
+                token_value = user_input.get(token_field)
+                if not token_value:
+                    errors[token_field] = "required"
+                    raise InvalidApiKey
+
+                # Store the configuration data
+                self.config_data[token_field] = token_value
+
+                # For z.ai, store endpoint type
+                if provider == "zai":
+                    endpoint_type = user_input.get("zai_endpoint", "general")
+                    self.config_data["zai_endpoint"] = endpoint_type
+
+                # For OpenAI, store Base URL (defaults to official endpoint if unchanged)
+                if provider == "openai":
+                    base_url = (user_input.get(CONF_OPENAI_BASE_URL) or "").strip()
+                    self.config_data[CONF_OPENAI_BASE_URL] = (
+                        base_url or "https://api.openai.com/v1"
+                    )
+                    # For OpenAI, move to next step to select model from dynamic list
+                    return await self.async_step_configure_openai_models()
+
+                # For OpenAI-Compatible, store Base URL + optional API key, then move on
+                if provider == "openai_compatible":
+                    base_url = (
+                        user_input.get(CONF_OPENAI_COMPATIBLE_URL) or ""
+                    ).strip()
+                    self.config_data[CONF_OPENAI_COMPATIBLE_URL] = base_url
+                    api_key = (
+                        user_input.get("openai_compatible_api_key") or ""
+                    ).strip()
+                    self.config_data["openai_compatible_api_key"] = api_key
+                    # Move to next step to select model from dynamic list
+                    return await self.async_step_configure_openai_compatible_models()
+
+                # Add model configuration if provided
+                selected_model = user_input.get("model")
+                custom_model = user_input.get("custom_model")
+
+                _LOGGER.debug(
+                    f"Config flow - Provider: {provider}, Selected model: {selected_model}, Custom model: {custom_model}"
+                )
+
+                # Initialize models dict if it doesn't exist
+                if "models" not in self.config_data:
+                    self.config_data["models"] = {}
+
+                if custom_model and custom_model.strip():
+                    # Use custom model if provided and not empty
+                    self.config_data["models"][provider] = custom_model.strip()
+                elif selected_model and selected_model != "Custom...":
+                    # Use selected model if it's not the "Custom..." option
+                    self.config_data["models"][provider] = selected_model
+                else:
+                    # For local_ollama, openai_compatible, alter, and zai providers, allow empty model name
+                    if provider in (
+                        "local_ollama",
+                        "openai_compatible",
+                        "alter",
+                        "zai",
+                    ):
+                        self.config_data["models"][provider] = ""
+                    else:
+                        # Fallback to default model for other providers
+                        self.config_data["models"][provider] = default_model
+
+                return self.async_create_entry(
+                    title=f"AI Agent HA ({PROVIDERS[provider]})",
+                    data=self.config_data,
+                )
+            except InvalidApiKey:
+                errors["base"] = "invalid_api_key"
+            except Exception:  # pylint: disable=broad-except
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+
+        if provider == "zai":
+            # For z.ai provider, we need token, endpoint type, and optional model name
+            model_options = AVAILABLE_MODELS.get("zai", ["Custom..."])
+            schema_dict = {
+                vol.Required(token_field): TextSelector(
+                    TextSelectorConfig(type="password")
+                ),
+                vol.Optional("zai_endpoint", default="general"): SelectSelector(
+                    SelectSelectorConfig(
+                        options=[
+                            {"value": "general", "label": "General Purpose"},
+                            {"value": "coding", "label": "Coding (3× usage, 1/7 cost)"},
+                        ]
+                    )
+                ),
+                vol.Optional("model", default="glm-4.7"): SelectSelector(
+                    SelectSelectorConfig(options=model_options)
+                ),
+                vol.Optional("custom_model"): TextSelector(
+                    TextSelectorConfig(type="text")
+                ),
+            }
+
+            return self.async_show_form(
+                step_id="configure",
+                data_schema=vol.Schema(schema_dict),
+                errors=errors,
+                description_placeholders={
+                    "token_label": token_label,
+                    "provider": PROVIDERS[provider],
+                },
+            )
+
+        if provider == "local_ollama":
+            # For local_ollama provider, we need both URL and optional model name
+            schema_dict = {
+                vol.Required(CONF_LOCAL_OLLAMA_URL): TextSelector(
+                    TextSelectorConfig(type="text")
+                ),
+            }
+
+            # Add model selection
+            model_options = AVAILABLE_MODELS.get("local_ollama", ["Custom..."])
+            schema_dict[vol.Optional("model", default="Custom...")] = SelectSelector(
+                SelectSelectorConfig(options=model_options)
+            )
+            schema_dict[vol.Optional("custom_model")] = TextSelector(
+                TextSelectorConfig(type="text")
+            )
+
+            return self.async_show_form(
+                step_id="configure",
+                data_schema=vol.Schema(schema_dict),
+                errors=errors,
+                description_placeholders={
+                    "token_label": "Local Ollama API URL",  # nosec B105 - UI label string shown next to the URL field, not a credential
+                    "provider": PROVIDERS[provider],
+                },
+            )
+
+        if provider == "openai_compatible":
+            # For openai_compatible provider, we need base URL + optional API key.
+            # Many local endpoints (LM Studio, vLLM) need no key; gateways like
+            # Open WebUI or LiteLLM require one. Models are fetched in the next step.
+            schema_dict = {
+                vol.Required(CONF_OPENAI_COMPATIBLE_URL): TextSelector(
+                    TextSelectorConfig(type="text")
+                ),
+                vol.Optional("openai_compatible_api_key", default=""): TextSelector(
+                    TextSelectorConfig(type="password")
+                ),
+            }
+
+            return self.async_show_form(
+                step_id="configure",
+                data_schema=vol.Schema(schema_dict),
+                errors=errors,
+                description_placeholders={
+                    "token_label": "Local OpenAI-Compatible URL",  # nosec B105 - UI label for config form, not a credential
+                    "provider": PROVIDERS[provider],
+                },
+            )
+
+        if provider == "openai":
+            # For OpenAI provider, first step: API Key + Base URL
+            # Model selection happens in the next step after we fetch available models
+            schema_dict = {
+                vol.Required(token_field): TextSelector(
+                    TextSelectorConfig(type="password")
+                ),
+                vol.Optional(
+                    CONF_OPENAI_BASE_URL,
+                    default="https://api.openai.com/v1",
+                ): TextSelector(TextSelectorConfig(type="text")),
+            }
+
+            return self.async_show_form(
+                step_id="configure",
+                data_schema=vol.Schema(schema_dict),
+                errors=errors,
+                description_placeholders={
+                    "token_label": token_label,
+                    "provider": PROVIDERS[provider],
+                },
+            )
+
+        # Build schema for other providers
+        schema_dict = {
+            vol.Required(token_field): TextSelector(
+                TextSelectorConfig(type="password")
+            ),
+        }
+
+        # Add model selection if available
+        if available_models:
+            # For Gemini, fetch models dynamically
+            if provider == "gemini":
+                token_value = self.config_data.get("gemini_token")
+                model_list = await fetch_gemini_models(token_value)
+                if "Custom..." not in model_list:
+                    model_list.insert(0, "Custom...")
+                model_options = model_list
+            else:
+                # Add predefined models + custom option (avoid duplicating "Custom...")
+                if "Custom..." in available_models:
+                    model_options = available_models
+                else:
+                    model_options = available_models + ["Custom..."]
+
+            schema_dict[vol.Optional("model", default=dropdown_default)] = (
+                SelectSelector(SelectSelectorConfig(options=model_options))
+            )
+            schema_dict[vol.Optional("custom_model")] = TextSelector(
+                TextSelectorConfig(type="text")
+            )
+
+        return self.async_show_form(
+            step_id="configure",
+            data_schema=vol.Schema(schema_dict),
+            errors=errors,
+            description_placeholders={
+                "token_label": token_label,
+                "provider": PROVIDERS[provider],
+            },
+        )
+
+    async def async_step_configure_openai_models(self, user_input=None):
+        """Handle the OpenAI model selection step with dynamic model list."""
+        errors = {}
+        provider = "openai"
+        token = self.config_data.get("openai_token")
+        base_url = self.config_data.get(
+            CONF_OPENAI_BASE_URL, "https://api.openai.com/v1"
+        )
+
+        # Fetch available models dynamically
+        model_list = await fetch_openai_models(base_url, token)
+
+        # Ensure "Custom..." is always available
+        if "Custom..." not in model_list:
+            model_list.insert(0, "Custom...")
+
+        if user_input is not None:
+            try:
+                selected_model = user_input.get("model")
+                custom_model = user_input.get("custom_model")
+
+                # Initialize models dict if it doesn't exist
+                if "models" not in self.config_data:
+                    self.config_data["models"] = {}
+
+                if custom_model and custom_model.strip():
+                    self.config_data["models"][provider] = custom_model.strip()
+                elif selected_model and selected_model != "Custom...":
+                    self.config_data["models"][provider] = selected_model
+                else:
+                    self.config_data["models"][provider] = ""
+
+                return self.async_create_entry(
+                    title=f"AI Agent HA ({PROVIDERS[provider]})",
+                    data=self.config_data,
+                )
+            except Exception:  # pylint: disable=broad-except
+                _LOGGER.exception("Unexpected exception in OpenAI model selection")
+                errors["base"] = "unknown"
+
+        schema_dict = {
+            vol.Optional("model", default="Custom..."): SelectSelector(
+                SelectSelectorConfig(options=model_list)
+            ),
+            vol.Optional("custom_model"): TextSelector(TextSelectorConfig(type="text")),
+        }
+
+        return self.async_show_form(
+            step_id="configure_openai_models",
+            data_schema=vol.Schema(schema_dict),
+            errors=errors,
+            description_placeholders={
+                "provider": PROVIDERS[provider],
+            },
+        )
+
+    async def async_step_configure_openai_compatible_models(self, user_input=None):
+        """Handle the OpenAI-Compatible model selection step with dynamic model list."""
+        errors = {}
+        provider = "openai_compatible"
+        base_url = self.config_data.get(CONF_OPENAI_COMPATIBLE_URL, "")
+        api_key = self.config_data.get("openai_compatible_api_key") or ""
+
+        # Fetch available models dynamically if the endpoint supports it
+        model_list = await fetch_openai_compatible_models(base_url, api_key or None)
+
+        # Ensure "Custom..." is always available
+        if "Custom..." not in model_list:
+            model_list.insert(0, "Custom...")
+
+        if user_input is not None:
+            try:
+                selected_model = user_input.get("model")
+                custom_model = user_input.get("custom_model")
+
+                # Initialize models dict if it doesn't exist
+                if "models" not in self.config_data:
+                    self.config_data["models"] = {}
+
+                if custom_model and custom_model.strip():
+                    self.config_data["models"][provider] = custom_model.strip()
+                elif selected_model and selected_model != "Custom...":
+                    self.config_data["models"][provider] = selected_model
+                else:
+                    self.config_data["models"][provider] = ""
+
+                return self.async_create_entry(
+                    title=f"AI Agent HA ({PROVIDERS[provider]})",
+                    data=self.config_data,
+                )
+            except Exception:  # pylint: disable=broad-except
+                _LOGGER.exception(
+                    "Unexpected exception in OpenAI-Compatible model selection"
+                )
+                errors["base"] = "unknown"
+
+        schema_dict = {
+            vol.Optional("model", default="Custom..."): SelectSelector(
+                SelectSelectorConfig(options=model_list)
+            ),
+            vol.Optional("custom_model"): TextSelector(TextSelectorConfig(type="text")),
+        }
+
+        return self.async_show_form(
+            step_id="configure_openai_compatible_models",
+            data_schema=vol.Schema(schema_dict),
+            errors=errors,
+            description_placeholders={
+                "provider": PROVIDERS[provider],
+            },
+        )
+
+
+class InvalidApiKey(HomeAssistantError):
+    """Error to indicate there is an invalid API key."""
+
+
+class AiAgentHaOptionsFlowHandler(config_entries.OptionsFlow):
+    """Handle options flow for AI Agent HA."""
+
+    def __init__(self):
+        """Initialize options flow."""
+        self.options_data = {}
+
+    async def async_step_init(self, user_input=None):
+        """Handle the initial options step - provider selection."""
+        current_provider = self.config_entry.data.get("ai_provider", DEFAULT_PROVIDER)
+
+        if user_input is not None:
+            # Store selected provider and move to configure step
+            self.options_data = {
+                "ai_provider": user_input["ai_provider"],
+                "current_provider": current_provider,
+            }
+            return await self.async_step_configure_options()
+
+        return self.async_show_form(
+            step_id="init",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(
+                        "ai_provider", default=current_provider
+                    ): SelectSelector(
+                        SelectSelectorConfig(
+                            options=[
+                                {"value": k, "label": v} for k, v in PROVIDERS.items()
+                            ]
+                        )
+                    ),
+                }
+            ),
+            description_placeholders={"current_provider": PROVIDERS[current_provider]},
+        )
+
+    async def async_step_configure_options(self, user_input=None):
+        """Handle the configuration step for the selected provider in options."""
+        errors = {}
+        provider = self.options_data["ai_provider"]
+        current_provider = self.options_data["current_provider"]
+        token_field = TOKEN_FIELD_NAMES[provider]
+        token_label = TOKEN_LABELS[provider]
+
+        # Get current configuration
+        current_models = self.config_entry.data.get("models", {})
+        current_model = current_models.get(provider, DEFAULT_MODELS[provider])
+        # For Alter provider, if model is empty, default to "Custom..." for the dropdown
+        if provider == "alter" and not current_model:
+            current_model = "Custom..."
+        current_token = self.config_entry.data.get(token_field, "")
+        available_models = AVAILABLE_MODELS.get(provider, [DEFAULT_MODELS[provider]])
+
+        # Use current token if provider hasn't changed, otherwise empty
+        display_token = current_token if provider == current_provider else ""
+
+        # Determine if current model is a custom model (not in available models list)
+        # and prepare model dropdown and custom model field defaults
+        model_options = available_models
+        if "Custom..." not in model_options:
+            model_options = model_options + ["Custom..."]
+
+        # Check if current_model is a custom model (not in the available models)
+        # Remove "Custom..." from the check since it's the selector option, not a real model
+        available_models_without_custom = [
+            m for m in available_models if m != "Custom..."
+        ]
+        is_custom_model = (
+            current_model
+            and current_model not in available_models_without_custom
+            and current_model != "Custom..."
+        )
+
+        if is_custom_model:
+            # Current model is a custom model - show "Custom..." in dropdown and populate custom field
+            model_default = "Custom..."
+            custom_model_default = current_model
+        else:
+            # Current model is a standard model or empty
+            model_default = current_model if current_model else "Custom..."
+            custom_model_default = ""
+
+        if user_input is not None:
+            try:
+                token_value = user_input.get(token_field)
+                if not token_value:
+                    errors[token_field] = "required"
+                else:
+                    # Prepare the updated configuration
+                    updated_data = dict(self.config_entry.data)
+                    updated_data["ai_provider"] = provider
+                    updated_data[token_field] = token_value
+
+                    # Update model configuration
+                    selected_model = user_input.get("model")
+                    custom_model = user_input.get("custom_model")
+
+                    # For zai, update endpoint type
+                    if provider == "zai":
+                        endpoint_type = user_input.get("zai_endpoint", "general")
+                        updated_data["zai_endpoint"] = endpoint_type
+
+                    # For OpenAI, update Base URL (default to official if blank)
+                    if provider == "openai":
+                        base_url = (user_input.get(CONF_OPENAI_BASE_URL) or "").strip()
+                        updated_data[CONF_OPENAI_BASE_URL] = (
+                            base_url or "https://api.openai.com/v1"
+                        )
+
+                    # For OpenAI-Compatible, update the optional API key
+                    if provider == "openai_compatible":
+                        updated_data["openai_compatible_api_key"] = (
+                            user_input.get("openai_compatible_api_key") or ""
+                        ).strip()
+
+                    # Initialize models dict if it doesn't exist
+                    if "models" not in updated_data:
+                        updated_data["models"] = {}
+
+                    if custom_model and custom_model.strip():
+                        # Use custom model if provided and not empty
+                        updated_data["models"][provider] = custom_model.strip()
+                    elif selected_model and selected_model != "Custom...":
+                        # Use selected model if it's not the "Custom..." option
+                        updated_data["models"][provider] = selected_model
+                    else:
+                        # For local_ollama, openai_compatible, alter, and zai providers, allow empty model name
+                        if provider in (
+                            "local_ollama",
+                            "openai_compatible",
+                            "alter",
+                            "zai",
+                        ):
+                            updated_data["models"][provider] = ""
+                        else:
+                            # Ensure we keep the current model or use default for other providers
+                            if provider not in updated_data["models"]:
+                                updated_data["models"][provider] = DEFAULT_MODELS[
+                                    provider
+                                ]
+
+                    _LOGGER.debug(
+                        f"Options flow - Final model config for {provider}: {updated_data['models'].get(provider)}"
+                    )
+
+                    # Update the config entry
+                    self.hass.config_entries.async_update_entry(
+                        self.config_entry, data=updated_data
+                    )
+
+                    return self.async_create_entry(title="", data={})
+            except Exception:  # pylint: disable=broad-except
+                _LOGGER.exception("Unexpected exception in options flow")
+                errors["base"] = "unknown"
+
+        # Build schema for the selected provider in options
+        if provider == "zai":
+            current_endpoint = self.config_entry.data.get("zai_endpoint", "general")
+            model_options = AVAILABLE_MODELS.get("zai", ["glm-4.7"])
+            # Ensure "Custom..." is in model options
+            if "Custom..." not in model_options:
+                model_options = model_options + ["Custom..."]
+            schema_dict = {
+                vol.Required(token_field, default=display_token): TextSelector(
+                    TextSelectorConfig(type="password")
+                ),
+                vol.Optional("zai_endpoint", default=current_endpoint): SelectSelector(
+                    SelectSelectorConfig(
+                        options=[
+                            {"value": "general", "label": "General Purpose"},
+                            {"value": "coding", "label": "Coding (3× usage, 1/7 cost)"},
+                        ]
+                    )
+                ),
+                vol.Optional("model", default=model_default): SelectSelector(
+                    SelectSelectorConfig(options=model_options)
+                ),
+                vol.Optional(
+                    "custom_model", default=custom_model_default
+                ): TextSelector(TextSelectorConfig(type="text")),
+            }
+
+            return self.async_show_form(
+                step_id="configure_options",
+                data_schema=vol.Schema(schema_dict),
+                errors=errors,
+                description_placeholders={
+                    "token_label": token_label,
+                    "provider": PROVIDERS[provider],
+                },
+            )
+
+        if provider == "local_ollama":
+            # For local_ollama provider, we need both URL and optional model name
+            current_url = self.config_entry.data.get(CONF_LOCAL_OLLAMA_URL, "")
+
+            schema_dict = {
+                vol.Required(CONF_LOCAL_OLLAMA_URL, default=current_url): TextSelector(
+                    TextSelectorConfig(type="text")
+                ),
+            }
+
+            # Add model selection
+            model_options = AVAILABLE_MODELS.get("local_ollama", ["Custom..."])
+            # Ensure "Custom..." is in model options
+            if "Custom..." not in model_options:
+                model_options = model_options + ["Custom..."]
+            schema_dict[vol.Optional("model", default=model_default)] = SelectSelector(
+                SelectSelectorConfig(options=model_options)
+            )
+            schema_dict[vol.Optional("custom_model", default=custom_model_default)] = (
+                TextSelector(TextSelectorConfig(type="text"))
+            )
+
+            return self.async_show_form(
+                step_id="configure_options",
+                data_schema=vol.Schema(schema_dict),
+                errors=errors,
+                description_placeholders={
+                    "token_label": "Local Ollama API URL",  # nosec B105 - UI label string shown next to the URL field, not a credential
+                    "provider": PROVIDERS[provider],
+                },
+            )
+
+        if provider == "openai_compatible":
+            # For openai_compatible provider, we need URL + optional API key + model
+            current_url = self.config_entry.data.get(CONF_OPENAI_COMPATIBLE_URL, "")
+            current_api_key = (
+                self.config_entry.data.get("openai_compatible_api_key") or ""
+            )
+
+            # Fetch available models dynamically if the endpoint supports it
+            model_list = await fetch_openai_compatible_models(
+                current_url, current_api_key or None
+            )
+
+            # Ensure "Custom..." is always available
+            if "Custom..." not in model_list:
+                model_list.insert(0, "Custom...")
+
+            schema_dict = {
+                vol.Required(
+                    CONF_OPENAI_COMPATIBLE_URL, default=current_url
+                ): TextSelector(TextSelectorConfig(type="text")),
+                vol.Optional(
+                    "openai_compatible_api_key", default=current_api_key
+                ): TextSelector(TextSelectorConfig(type="password")),
+            }
+
+            # Add model selection with dynamic list
+            schema_dict[vol.Optional("model", default=model_default)] = SelectSelector(
+                SelectSelectorConfig(options=model_list)
+            )
+            schema_dict[vol.Optional("custom_model", default=custom_model_default)] = (
+                TextSelector(TextSelectorConfig(type="text"))
+            )
+
+            return self.async_show_form(
+                step_id="configure_options",
+                data_schema=vol.Schema(schema_dict),
+                errors=errors,
+                description_placeholders={
+                    "token_label": "Local OpenAI-Compatible URL",  # nosec B105 - UI label for config form, not a credential
+                    "provider": PROVIDERS[provider],
+                },
+            )
+
+        if provider == "openai":
+            # For OpenAI provider, we need token and optional Base URL
+            # Pre-fill with official endpoint if not set
+            current_base_url = (
+                self.config_entry.data.get(CONF_OPENAI_BASE_URL)
+                or "https://api.openai.com/v1"
+            )
+
+            # Fetch available models dynamically
+            current_token = self.config_entry.data.get("openai_token", "")
+            model_list = await fetch_openai_models(current_base_url, current_token)
+
+            # Ensure "Custom..." is always available
+            if "Custom..." not in model_list:
+                model_list.insert(0, "Custom...")
+
+            schema_dict = {
+                vol.Required(token_field, default=display_token): TextSelector(
+                    TextSelectorConfig(type="password")
+                ),
+                vol.Optional(
+                    CONF_OPENAI_BASE_URL, default=current_base_url
+                ): TextSelector(TextSelectorConfig(type="text")),
+            }
+
+            # Add model selection with dynamic list
+            schema_dict[vol.Optional("model", default=model_default)] = SelectSelector(
+                SelectSelectorConfig(options=model_list)
+            )
+            schema_dict[vol.Optional("custom_model", default=custom_model_default)] = (
+                TextSelector(TextSelectorConfig(type="text"))
+            )
+
+            return self.async_show_form(
+                step_id="configure_options",
+                data_schema=vol.Schema(schema_dict),
+                errors=errors,
+                description_placeholders={
+                    "token_label": token_label,
+                    "provider": PROVIDERS[provider],
+                },
+            )
+
+        # Build schema for other providers
+        schema_dict = {
+            vol.Required(token_field, default=display_token): TextSelector(
+                TextSelectorConfig(type="password")
+            ),
+        }
+
+        # Add model selection if available
+        if available_models:
+            # For Gemini, fetch models dynamically
+            if provider == "gemini":
+                current_token = self.config_entry.data.get("gemini_token", "")
+                model_list = await fetch_gemini_models(current_token)
+                if "Custom..." not in model_list:
+                    model_list.insert(0, "Custom...")
+                model_options = model_list
+            # model_options already has "Custom..." added above for other providers
+
+            schema_dict[vol.Optional("model", default=model_default)] = SelectSelector(
+                SelectSelectorConfig(options=model_options)
+            )
+            schema_dict[vol.Optional("custom_model", default=custom_model_default)] = (
+                TextSelector(TextSelectorConfig(type="text"))
+            )
+
+        return self.async_show_form(
+            step_id="configure_options",
+            data_schema=vol.Schema(schema_dict),
+            errors=errors,
+            description_placeholders={
+                "token_label": token_label,
+                "provider": PROVIDERS[provider],
+            },
+        )

custom_components/ai_agent_ha/const.py

@@ -0,0 +1,40 @@
+"""Constants for the AI Agent HA integration."""
+
+DOMAIN = "ai_agent_ha"
+CONF_API_KEY = "api_key"
+CONF_WEATHER_ENTITY = "weather_entity"
+
+# AI Provider configuration keys
+CONF_LLAMA_TOKEN = "llama_token"  # nosec B105
+CONF_OPENAI_TOKEN = "openai_token"  # nosec B105
+CONF_OPENAI_BASE_URL = (
+    "openai_base_url"  # nosec B105 - configuration key, not a credential
+)
+CONF_GEMINI_TOKEN = "gemini_token"  # nosec B105
+CONF_OPENROUTER_TOKEN = "openrouter_token"  # nosec B105
+CONF_ANTHROPIC_TOKEN = "anthropic_token"  # nosec B105
+CONF_ALTER_TOKEN = "alter_token"  # nosec B105
+CONF_ZAI_TOKEN = "zai_token"  # nosec B105
+CONF_LOCAL_OLLAMA_URL = "local_ollama_url"
+CONF_LOCAL_OLLAMA_MODEL = "local_ollama_model"
+CONF_OPENAI_COMPATIBLE_URL = "openai_compatible_url"
+CONF_LOCAL_URL = "local_url"  # legacy alias for local_ollama_url
+
+# Available AI providers
+AI_PROVIDERS = [
+    "llama",
+    "openai",
+    "gemini",
+    "openrouter",
+    "anthropic",
+    "alter",
+    "zai",
+    "local_ollama",
+    "openai_compatible",
+]
+
+# AI Provider constants
+CONF_MODELS = "models"
+
+# Supported AI providers
+DEFAULT_AI_PROVIDER = "openai"

custom_components/ai_agent_ha/dashboard_templates.py

@@ -0,0 +1,390 @@
+"""
+Dashboard templates and examples for AI agent to use when creating dashboards.
+"""
+
+# Basic dashboard templates for different use cases
+DASHBOARD_TEMPLATES = {
+    "simple_lights": {
+        "title": "Lights Dashboard",
+        "url_path": "lights",
+        "icon": "mdi:lightbulb",
+        "show_in_sidebar": True,
+        "views": [
+            {
+                "title": "All Lights",
+                "cards": [
+                    {
+                        "type": "entities",
+                        "title": "Living Room Lights",
+                        "entities": [],  # To be filled with actual light entities
+                    },
+                    {
+                        "type": "light",
+                        "entity": "",  # To be filled with main light entity
+                    },
+                ],
+            }
+        ],
+    },
+    "security": {
+        "title": "Security Dashboard",
+        "url_path": "security",
+        "icon": "mdi:security",
+        "show_in_sidebar": True,
+        "views": [
+            {
+                "title": "Security Overview",
+                "cards": [
+                    {
+                        "type": "entities",
+                        "title": "Sensors",
+                        "entities": [],  # To be filled with sensor entities
+                    },
+                    {
+                        "type": "entities",
+                        "title": "Cameras",
+                        "entities": [],  # To be filled with camera entities
+                    },
+                    {
+                        "type": "alarm-panel",
+                        "entity": "",  # To be filled with alarm panel entity
+                    },
+                ],
+            }
+        ],
+    },
+    "climate": {
+        "title": "Climate Control",
+        "url_path": "climate",
+        "icon": "mdi:thermometer",
+        "show_in_sidebar": True,
+        "views": [
+            {
+                "title": "Temperature & Humidity",
+                "cards": [
+                    {
+                        "type": "thermostat",
+                        "entity": "",  # To be filled with climate.* thermostat entity (optional)
+                    },
+                    {
+                        "type": "history-graph",
+                        "title": "Temperature History",
+                        "entities": [],  # To be filled with temperature sensor entities
+                        "hours_to_show": 24,
+                    },
+                    {
+                        "type": "entities",
+                        "title": "Temperature Sensors",
+                        "entities": [],  # To be filled with temperature sensor entities (device_class: temperature)
+                    },
+                    {
+                        "type": "history-graph",
+                        "title": "Humidity History",
+                        "entities": [],  # To be filled with humidity sensor entities
+                        "hours_to_show": 24,
+                    },
+                    {
+                        "type": "entities",
+                        "title": "Humidity Sensors",
+                        "entities": [],  # To be filled with humidity sensor entities (device_class: humidity)
+                    },
+                    {
+                        "type": "weather-forecast",
+                        "entity": "",  # To be filled with weather entity (optional)
+                    },
+                ],
+            }
+        ],
+    },
+    "media": {
+        "title": "Media Center",
+        "url_path": "media",
+        "icon": "mdi:play",
+        "show_in_sidebar": True,
+        "views": [
+            {
+                "title": "Media Players",
+                "cards": [
+                    {
+                        "type": "media-control",
+                        "entity": "",  # To be filled with media player entity
+                    },
+                    {
+                        "type": "entities",
+                        "title": "All Media Players",
+                        "entities": [],  # To be filled with media player entities
+                    },
+                ],
+            }
+        ],
+    },
+    "energy": {
+        "title": "Energy Monitoring",
+        "url_path": "energy",
+        "icon": "mdi:lightning-bolt",
+        "show_in_sidebar": True,
+        "views": [
+            {
+                "title": "Energy Usage",
+                "cards": [
+                    {"type": "energy-distribution", "title": "Energy Distribution"},
+                    {
+                        "type": "entities",
+                        "title": "Power Sensors",
+                        "entities": [],  # To be filled with power sensor entities
+                    },
+                    {
+                        "type": "history-graph",
+                        "title": "Power Usage",
+                        "entities": [],  # To be filled with power entities
+                    },
+                ],
+            }
+        ],
+    },
+}
+
+# Card type examples and their typical use cases
+CARD_EXAMPLES = {
+    "entities": {
+        "description": "Shows a list of entities with their states",
+        "example": {
+            "type": "entities",
+            "title": "Living Room",
+            "entities": [
+                "light.living_room_main",
+                "switch.living_room_fan",
+                "sensor.living_room_temperature",
+            ],
+        },
+    },
+    "glance": {
+        "description": "Shows entities in a compact grid format",
+        "example": {
+            "type": "glance",
+            "title": "Quick Overview",
+            "entities": [
+                "binary_sensor.front_door",
+                "binary_sensor.back_door",
+                "binary_sensor.garage_door",
+            ],
+        },
+    },
+    "thermostat": {
+        "description": "Controls and displays thermostat information",
+        "example": {"type": "thermostat", "entity": "climate.main_thermostat"},
+    },
+    "weather-forecast": {
+        "description": "Shows weather information and forecast",
+        "example": {
+            "type": "weather-forecast",
+            "entity": "weather.home",
+            "name": "Weather",
+        },
+    },
+    "media-control": {
+        "description": "Controls media players with full interface",
+        "example": {"type": "media-control", "entity": "media_player.living_room_tv"},
+    },
+    "light": {
+        "description": "Dedicated light control card",
+        "example": {"type": "light", "entity": "light.living_room_main"},
+    },
+    "alarm-panel": {
+        "description": "Security alarm panel interface",
+        "example": {"type": "alarm-panel", "entity": "alarm_control_panel.home_alarm"},
+    },
+    "picture-entity": {
+        "description": "Shows entity state with a background image",
+        "example": {
+            "type": "picture-entity",
+            "entity": "light.living_room",
+            "image": "/local/living_room.jpg",
+        },
+    },
+    "history-graph": {
+        "description": "Shows historical data as a graph",
+        "example": {
+            "type": "history-graph",
+            "title": "Temperature History",
+            "entities": ["sensor.temperature_indoor", "sensor.temperature_outdoor"],
+            "hours_to_show": 24,
+        },
+    },
+    "gauge": {
+        "description": "Shows a single entity value as a gauge",
+        "example": {
+            "type": "gauge",
+            "entity": "sensor.cpu_temperature",
+            "min": 0,
+            "max": 100,
+            "name": "CPU Temperature",
+        },
+    },
+}
+
+# Predefined color schemes and icons
+COMMON_ICONS = {
+    "lights": "mdi:lightbulb",
+    "security": "mdi:security",
+    "climate": "mdi:thermometer",
+    "energy": "mdi:lightning-bolt",
+    "media": "mdi:play",
+    "kitchen": "mdi:chef-hat",
+    "bedroom": "mdi:bed",
+    "bathroom": "mdi:shower",
+    "living_room": "mdi:sofa",
+    "garage": "mdi:garage",
+    "garden": "mdi:flower",
+    "office": "mdi:desk",
+    "basement": "mdi:stairs-down",
+    "attic": "mdi:stairs-up",
+}
+
+
+def get_template_for_entities(entities, dashboard_type="general"):
+    """Generate a dashboard template based on available entities."""
+    template = {
+        "title": f"{dashboard_type.title()} Dashboard",
+        "url_path": dashboard_type.lower().replace(" ", "-"),
+        "icon": COMMON_ICONS.get(dashboard_type, "mdi:view-dashboard"),
+        "show_in_sidebar": True,
+        "views": [],
+    }
+
+    # Group entities by domain and by device_class for sensors
+    entity_groups = {}
+    sensor_by_device_class = {}
+
+    for entity in entities:
+        if isinstance(entity, dict) and "entity_id" in entity:
+            entity_id = entity["entity_id"]
+            # Get device_class from attributes if available
+            device_class = entity.get("attributes", {}).get("device_class")
+        else:
+            entity_id = str(entity)
+            device_class = None
+
+        domain = entity_id.split(".")[0]
+        if domain not in entity_groups:
+            entity_groups[domain] = []
+        entity_groups[domain].append(entity_id)
+
+        # Categorize sensors by device_class
+        if domain == "sensor" and device_class:
+            if device_class not in sensor_by_device_class:
+                sensor_by_device_class[device_class] = []
+            sensor_by_device_class[device_class].append(entity_id)
+
+    # Create view with cards for each domain
+    view_cards = []
+
+    # Lights
+    if "light" in entity_groups:
+        view_cards.append(
+            {"type": "entities", "title": "Lights", "entities": entity_groups["light"]}
+        )
+
+    # Climate - handle both climate entities and temperature/humidity sensors
+    if "climate" in entity_groups:
+        for climate_entity in entity_groups["climate"]:
+            view_cards.append({"type": "thermostat", "entity": climate_entity})
+
+    # Temperature sensors - create history graphs for climate dashboards
+    if "temperature" in sensor_by_device_class:
+        temp_sensors = sensor_by_device_class["temperature"]
+        # Add history graph for temperature visualization
+        view_cards.append(
+            {
+                "type": "history-graph",
+                "title": "Temperature History",
+                "entities": temp_sensors,
+                "hours_to_show": 24,
+            }
+        )
+        # Add entity card for current values
+        view_cards.append(
+            {
+                "type": "entities",
+                "title": "Temperature Sensors",
+                "entities": temp_sensors,
+            }
+        )
+
+    # Humidity sensors - create gauge cards for climate dashboards
+    if "humidity" in sensor_by_device_class:
+        humidity_sensors = sensor_by_device_class["humidity"]
+        # Add history graph for humidity visualization
+        view_cards.append(
+            {
+                "type": "history-graph",
+                "title": "Humidity History",
+                "entities": humidity_sensors,
+                "hours_to_show": 24,
+            }
+        )
+        # Add entity card for current values
+        view_cards.append(
+            {
+                "type": "entities",
+                "title": "Humidity Sensors",
+                "entities": humidity_sensors,
+            }
+        )
+
+    # Media players
+    if "media_player" in entity_groups:
+        for media_entity in entity_groups["media_player"]:
+            view_cards.append({"type": "media-control", "entity": media_entity})
+
+    # Security entities
+    if "binary_sensor" in entity_groups:
+        view_cards.append(
+            {
+                "type": "entities",
+                "title": "Sensors",
+                "entities": entity_groups["binary_sensor"],
+            }
+        )
+
+    if "alarm_control_panel" in entity_groups:
+        for alarm_entity in entity_groups["alarm_control_panel"]:
+            view_cards.append({"type": "alarm-panel", "entity": alarm_entity})
+
+    # Other Sensors (not temperature or humidity)
+    if "sensor" in entity_groups:
+        # Filter out temperature and humidity sensors that we already handled
+        other_sensors = [
+            s
+            for s in entity_groups["sensor"]
+            if s not in sensor_by_device_class.get("temperature", [])
+            and s not in sensor_by_device_class.get("humidity", [])
+        ]
+        if other_sensors:
+            view_cards.append(
+                {
+                    "type": "entities",
+                    "title": "Other Sensors",
+                    "entities": other_sensors[:10],  # Limit to first 10
+                }
+            )
+
+    # Switches
+    if "switch" in entity_groups:
+        view_cards.append(
+            {
+                "type": "entities",
+                "title": "Switches",
+                "entities": entity_groups["switch"],
+            }
+        )
+
+    # Weather
+    if "weather" in entity_groups:
+        view_cards.append(
+            {"type": "weather-forecast", "entity": entity_groups["weather"][0]}
+        )
+
+    template["views"] = [{"title": "Overview", "cards": view_cards}]
+
+    return template

custom_components/ai_agent_ha/frontend.yaml

@@ -0,0 +1,8 @@
+panel_custom:
+  - name: AI Agent HA
+    sidebar_title: AI Agent HA
+    sidebar_icon: mdi:robot
+    url_path: ai_agent_ha
+    module_url: /local/ai_agent_ha/frontend/ai_agent_ha-panel.js
+    trust_external: true
+    require_admin: false 

custom_components/ai_agent_ha/manifest.json

@@ -0,0 +1,24 @@
+{
+    "domain": "ai_agent_ha",
+    "name": "AI Agent HA",
+    "after_dependencies": [
+        "history",
+        "recorder",
+        "lovelace"
+    ],
+    "codeowners": [
+        "@sbenodiz"
+    ],
+    "config_flow": true,
+    "dependencies": [
+        "http"
+    ],
+    "documentation": "https://github.com/sbenodiz/ai_agent_ha",
+    "integration_type": "service",
+    "iot_class": "cloud_polling",
+    "issue_tracker": "https://github.com/sbenodiz/ai_agent_ha/issues",
+    "requirements": [
+        "aiohttp>=3.8.0"
+    ],
+    "version": "1.14.1"
+}

custom_components/ai_agent_ha/services.yaml

@@ -0,0 +1,98 @@
+query:
+  name: "Query AI Agent with Home Assistant context"
+  description: "Run a custom AI prompt against your Home Assistant state dump."
+  fields:
+    prompt:
+      description: "The question or instruction to send to AI model."
+      example: "Turn on all the lights in the living room"
+    debug:
+      description: "Include a debug trace of the HA↔AI conversation (true/false)."
+      example: true
+      default: false
+    provider:
+      description: "The AI provider to use (openai, llama, gemini, openrouter, anthropic, alter, zai, local)"
+      example: "openai"
+      default: "openai"
+      selector:
+        select:
+          options:
+            - "openai"
+            - "llama"
+            - "gemini"
+            - "openrouter"
+            - "anthropic"
+            - "alter"
+            - "zai"
+            - "local"
+
+create_dashboard:
+  name: "Create Dashboard via AI Agent"
+  description: "Create a new Home Assistant dashboard using AI assistance."
+  fields:
+    dashboard_config:
+      description: "The dashboard configuration as a JSON object."
+      example: '{"title": "My Dashboard", "url_path": "my-dashboard", "views": []}'
+    provider:
+      description: "The AI provider to use (openai, llama, gemini, openrouter, anthropic, alter, zai, local)"
+      example: "openai"
+      default: "openai"
+      selector:
+        select:
+          options:
+            - "openai"
+            - "llama"
+            - "gemini"
+            - "openrouter"
+            - "anthropic"
+            - "alter"
+            - "zai"
+            - "local"
+
+create_automation:
+  name: "Create Automation via AI Agent"
+  description: "Create a new Home Assistant automation using AI assistance."
+  fields:
+    automation:
+      description: "The automation configuration as a JSON object."
+      example: '{"alias": "Turn off lights at 9 PM", "trigger": [{"platform": "time", "at": "21:00:00"}], "action": [{"service": "light.turn_off", "target": {"entity_id": "light.living_room"}}]}'
+    provider:
+      description: "The AI provider to use (openai, llama, gemini, openrouter, anthropic, alter, zai, local)"
+      example: "openai"
+      default: "openai"
+      selector:
+        select:
+          options:
+            - "openai"
+            - "llama"
+            - "gemini"
+            - "openrouter"
+            - "anthropic"
+            - "alter"
+            - "zai"
+            - "local"
+
+update_dashboard:
+  name: "Update Dashboard via AI Agent"
+  description: "Update an existing Home Assistant dashboard using AI assistance."
+  fields:
+    dashboard_url:
+      description: "The URL path of dashboard to update."
+      example: "my-dashboard"
+    dashboard_config:
+      description: "The updated dashboard configuration as a JSON object."
+      example: '{"title": "Updated Dashboard", "views": []}'
+    provider:
+      description: "The AI provider to use (openai, llama, gemini, openrouter, anthropic, alter, zai, local)"
+      example: "openai"
+      default: "openai"
+      selector:
+        select:
+          options:
+            - "openai"
+            - "llama"
+            - "gemini"
+            - "openrouter"
+            - "anthropic"
+            - "alter"
+            - "zai"
+            - "local"

custom_components/ai_agent_ha/strings.json

@@ -0,0 +1,91 @@
+{
+    "config": {
+        "step": {
+            "user": {
+                "title": "Choose AI Provider",
+                "description": "Select your AI provider",
+                "data": {
+                    "ai_provider": "AI Provider"
+                },
+                "data_description": {
+                    "ai_provider": "Choose your preferred AI provider"
+                }
+            },
+            "configure": {
+                "title": "Configure {provider}",
+                "description": "Enter your {token_label} and optionally select a model",
+                "data": {
+                    "llama_token": "Llama API Token",
+                    "openai_token": "OpenAI API Key",
+                    "gemini_token": "Google Gemini API Key",
+                    "openrouter_token": "OpenRouter API Key",
+                    "anthropic_token": "Anthropic API Key",
+                    "alter_token": "Alter API Key",
+                    "model": "Model (Optional)",
+                    "custom_model": "Custom Model (Optional)"
+                },
+                "data_description": {
+                    "llama_token": "Enter your Llama API token",
+                    "openai_token": "Enter your OpenAI API key",
+                    "gemini_token": "Enter your Google Gemini API key",
+                    "openrouter_token": "Enter your OpenRouter API key",
+                    "anthropic_token": "Enter your Anthropic API key",
+                    "alter_token": "Enter your Alter API key",
+                    "model": "Choose a predefined model or select 'Custom...' to enter your own",
+                    "custom_model": "Enter a custom model name (only used if 'Custom...' is selected above)"
+                }
+            }
+        },
+        "error": {
+            "invalid_api_key": "Invalid API key format",
+            "unknown": "Unknown error occurred",
+            "llama_token": "Llama API token is required",
+            "openai_token": "OpenAI API key is required",
+            "gemini_token": "Google Gemini API key is required",
+            "openrouter_token": "OpenRouter API key is required",
+            "anthropic_token": "Anthropic API key is required",
+            "alter_token": "Alter API key is required"
+        },
+        "abort": {
+            "already_configured": "AI Agent HA is already configured"
+        }
+    },
+    "options": {
+        "step": {
+            "init": {
+                "title": "AI Provider Settings",
+                "description": "Current provider: {current_provider}. Select a provider to configure",
+                "data": {
+                    "ai_provider": "AI Provider"
+                },
+                "data_description": {
+                    "ai_provider": "Choose your preferred AI provider"
+                }
+            },
+            "configure_options": {
+                "title": "Configure {provider}",
+                "description": "Update your {token_label} and model settings",
+                "data": {
+                    "llama_token": "Llama API Token",
+                    "openai_token": "OpenAI API Key",
+                    "gemini_token": "Google Gemini API Key",
+                    "openrouter_token": "OpenRouter API Key",
+                    "anthropic_token": "Anthropic API Key",
+                    "alter_token": "Alter API Key",
+                    "model": "Model",
+                    "custom_model": "Custom Model (Optional)"
+                },
+                "data_description": {
+                    "llama_token": "Enter your Llama API token",
+                    "openai_token": "Enter your OpenAI API key",
+                    "gemini_token": "Enter your Google Gemini API key",
+                    "openrouter_token": "Enter your OpenRouter API key",
+                    "anthropic_token": "Enter your Anthropic API key",
+                    "alter_token": "Enter your Alter API key",
+                    "model": "Choose a model or select 'Custom...' to enter your own",
+                    "custom_model": "Enter a custom model name (only used if 'Custom...' is selected above)"
+                }
+            }
+        }
+    }
+} 

custom_components/ai_agent_ha/translations/ca.json

@@ -0,0 +1,81 @@
+{
+    "config": {
+        "step": {
+            "user": {
+                "title": "Agent d'IA HA - Seleccionar proveïdor",
+                "description": "Tria el teu proveïdor d'IA",
+                "data": {
+                    "ai_provider": "Proveïdor d'IA"
+                },
+                "data_description": {
+                    "ai_provider": "Selecciona el teu proveïdor d'IA preferit"
+                }
+            },
+            "configure": {
+                "title": "Agent d'IA HA - Configurar {provider}",
+                "description": "Configura les teves credencials d'API i el model de {provider}",
+                "data": {
+                    "llama_token": "Token de l'API de Llama",
+                    "openai_token": "Clau de l'API d'OpenAI",
+                    "gemini_token": "Clau de l'API de Google Gemini",
+                    "openrouter_token": "Clau de l'API d'OpenRouter",
+                    "model": "Model (Opcional)",
+                    "custom_model": "Nom del model personalitzat (Opcional)"
+                },
+                "data_description": {
+                    "llama_token": "Introdueix el teu token de l'API de Llama",
+                    "openai_token": "Introdueix la teva clau de l'API d'OpenAI",
+                    "gemini_token": "Introdueix la teva clau de l'API de Google Gemini",
+                    "openrouter_token": "Introdueix la teva clau de l'API d'OpenRouter",
+                    "model": "Tria un model predefinit o selecciona 'Personalitzat...' per utilitzar un model personalitzat",
+                    "custom_model": "Introdueix un nom de model personalitzat (anul·la la selecció desplegable anterior)"
+                }
+            }
+        },
+        "error": {
+            "invalid_api_key": "Clau o token d'API no vàlid",
+            "llama_token": "Es requereix el token de l'API de Llama",
+            "openai_token": "Es requereix la clau de l'API d'OpenAI",
+            "gemini_token": "Es requereix la clau de l'API de Google Gemini",
+            "openrouter_token": "Es requereix la clau de l'API d'OpenRouter",
+            "unknown": "S'ha produït un error inesperat"
+        },
+        "abort": {
+            "already_configured": "L'Agent d'IA HA ja està configurat"
+        }
+    },
+    "options": {
+        "step": {
+            "init": {
+                "title": "Agent d'IA HA - Seleccionar proveïdor",
+                "description": "Tria el teu proveïdor d'IA (Actual: {current_provider})",
+                "data": {
+                    "ai_provider": "Proveïdor d'IA"
+                },
+                "data_description": {
+                    "ai_provider": "Selecciona el teu proveïdor d'IA preferit"
+                }
+            },
+            "configure_options": {
+                "title": "Agent d'IA HA - Configurar {provider}",
+                "description": "Actualitza les teves credencials d'API i el model de {provider}",
+                "data": {
+                    "llama_token": "Token de l'API de Llama",
+                    "openai_token": "Clau de l'API d'OpenAI",
+                    "gemini_token": "Clau de l'API de Google Gemini",
+                    "openrouter_token": "Clau de l'API d'OpenRouter",
+                    "model": "Model (Opcional)",
+                    "custom_model": "Nom del model personalitzat (Opcional)"
+                },
+                "data_description": {
+                    "llama_token": "Introdueix el teu token de l'API de Llama",
+                    "openai_token": "Introdueix la teva clau de l'API d'OpenAI",
+                    "gemini_token": "Introdueix la teva clau de l'API de Google Gemini",
+                    "openrouter_token": "Introdueix la teva clau de l'API d'OpenRouter",
+                    "model": "Tria un model predefinit o selecciona 'Personalitzat...' per utilitzar un model personalitzat",
+                    "custom_model": "Introdueix un nom de model personalitzat (anul·la la selecció desplegable anterior)"
+                }
+            }
+        }
+    }
+}

custom_components/ai_agent_ha/translations/de.json

@@ -0,0 +1,86 @@
+{
+  "config": {
+    "step": {
+      "user": {
+        "title": "KI-Anbieter wählen",
+        "description": "Wähle deinen KI-Anbieter aus",
+        "data": {
+          "ai_provider": "KI-Anbieter"
+        },
+        "data_description": {
+          "ai_provider": "Wähle deinen bevorzugten KI-Anbieter"
+        }
+      },
+      "configure": {
+        "title": "{provider} konfigurieren",
+        "description": "Gib deinen {token_label} ein und wähle optional ein Model",
+        "data": {
+          "llama_token": "Llama API Token",
+          "openai_token": "OpenAI API Key",
+          "gemini_token": "Google Gemini API Key",
+          "openrouter_token": "OpenRouter API Key",
+          "anthropic_token": "Anthropic API Key",
+          "model": "Model (Optional)",
+          "custom_model": "Custom Model (Optional)"
+        },
+        "data_description": {
+          "llama_token": "Gib deinen Llama API Token ein",
+          "openai_token": "Gib deinen OpenAI API Key ein",
+          "gemini_token": "Gib deinen Google Gemini API Key ein",
+          "openrouter_token": "Gib deinen OpenRouter API Key ein",
+          "anthropic_token": "Gib deinen Anthropic API Key ein",
+          "model": "Wähle ein vordefiniertes Model oder 'Custom...' zum manuellen Eintrag",
+          "custom_model": "Gib einen benutzerdefinierten Model-Namen ein (nur relevant bei Auswahl von 'Custom...')"
+        }
+      }
+    },
+    "error": {
+      "invalid_api_key": "Ungültiges API-Key-Format",
+      "unknown": "Unbekannter Fehler aufgetreten",
+      "llama_token": "Llama API Token ist erforderlich",
+      "openai_token": "OpenAI API Key ist erforderlich",
+      "gemini_token": "Google Gemini API Key ist erforderlich",
+      "openrouter_token": "OpenRouter API Key ist erforderlich",
+      "anthropic_token": "Anthropic API Key ist erforderlich"
+    },
+    "abort": {
+      "already_configured": "AI Agent HA ist bereits konfiguriert"
+    }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "title": "Einstellungen für KI-Anbieter",
+        "description": "Aktueller Anbieter: {current_provider}. Wähle einen Anbieter zur Konfiguration",
+        "data": {
+          "ai_provider": "KI-Anbieter"
+        },
+        "data_description": {
+          "ai_provider": "Wähle deinen bevorzugten KI-Anbieter"
+        }
+      },
+      "configure_options": {
+        "title": "{provider} konfigurieren",
+        "description": "Aktualisiere deinen {token_label} und Model-Einstellungen",
+        "data": {
+          "llama_token": "Llama API Token",
+          "openai_token": "OpenAI API Key",
+          "gemini_token": "Google Gemini API Key",
+          "openrouter_token": "OpenRouter API Key",
+          "anthropic_token": "Anthropic API Key",
+          "model": "Model",
+          "custom_model": "Custom Model (Optional)"
+        },
+        "data_description": {
+          "llama_token": "Gib deinen Llama API Token ein",
+          "openai_token": "Gib deinen OpenAI API Key ein",
+          "gemini_token": "Gib deinen Google Gemini API Key ein",
+          "openrouter_token": "Gib deinen OpenRouter API Key ein",
+          "anthropic_token": "Gib deinen Anthropic API Key ein",
+          "model": "Wähle ein Model oder 'Custom...' zum manuellen Eintrag",
+          "custom_model": "Gib einen benutzerdefinierten Model-Namen ein (nur relevant bei Auswahl von 'Custom...')"
+        }
+      }
+    }
+  }
+}

custom_components/ai_agent_ha/translations/en.json

@@ -0,0 +1,91 @@
+{
+    "config": {
+        "step": {
+            "user": {
+                "title": "Choose AI Provider",
+                "description": "Select your AI provider",
+                "data": {
+                    "ai_provider": "AI Provider"
+                },
+                "data_description": {
+                    "ai_provider": "Choose your preferred AI provider"
+                }
+            },
+            "configure": {
+                "title": "Configure {provider}",
+                "description": "Enter your {token_label} and optionally select a model",
+                "data": {
+                    "llama_token": "Llama API Token",
+                    "openai_token": "OpenAI API Key",
+                    "gemini_token": "Google Gemini API Key",
+                    "openrouter_token": "OpenRouter API Key",
+                    "anthropic_token": "Anthropic API Key",
+                    "alter_token": "Alter API Key",
+                    "model": "Model (Optional)",
+                    "custom_model": "Custom Model (Optional)"
+                },
+                "data_description": {
+                    "llama_token": "Enter your Llama API token",
+                    "openai_token": "Enter your OpenAI API key",
+                    "gemini_token": "Enter your Google Gemini API key",
+                    "openrouter_token": "Enter your OpenRouter API key",
+                    "anthropic_token": "Enter your Anthropic API key",
+                    "alter_token": "Enter your Alter API key",
+                    "model": "Choose a predefined model or select 'Custom...' to enter your own",
+                    "custom_model": "Enter a custom model name (only used if 'Custom...' is selected above)"
+                }
+            }
+        },
+        "error": {
+            "invalid_api_key": "Invalid API key format",
+            "unknown": "Unknown error occurred",
+            "llama_token": "Llama API token is required",
+            "openai_token": "OpenAI API key is required",
+            "gemini_token": "Google Gemini API key is required",
+            "openrouter_token": "OpenRouter API key is required",
+            "anthropic_token": "Anthropic API key is required",
+            "alter_token": "Alter API key is required"
+        },
+        "abort": {
+            "already_configured": "AI Agent HA is already configured"
+        }
+    },
+    "options": {
+        "step": {
+            "init": {
+                "title": "AI Provider Settings",
+                "description": "Current provider: {current_provider}. Select a provider to configure",
+                "data": {
+                    "ai_provider": "AI Provider"
+                },
+                "data_description": {
+                    "ai_provider": "Choose your preferred AI provider"
+                }
+            },
+            "configure_options": {
+                "title": "Configure {provider}",
+                "description": "Update your {token_label} and model settings",
+                "data": {
+                    "llama_token": "Llama API Token",
+                    "openai_token": "OpenAI API Key",
+                    "gemini_token": "Google Gemini API Key",
+                    "openrouter_token": "OpenRouter API Key",
+                    "anthropic_token": "Anthropic API Key",
+                    "alter_token": "Alter API Key",
+                    "model": "Model",
+                    "custom_model": "Custom Model (Optional)"
+                },
+                "data_description": {
+                    "llama_token": "Enter your Llama API token",
+                    "openai_token": "Enter your OpenAI API key",
+                    "gemini_token": "Enter your Google Gemini API key",
+                    "openrouter_token": "Enter your OpenRouter API key",
+                    "anthropic_token": "Enter your Anthropic API key",
+                    "alter_token": "Enter your Alter API key",
+                    "model": "Choose a model or select 'Custom...' to enter your own",
+                    "custom_model": "Enter a custom model name (only used if 'Custom...' is selected above)"
+                }
+            }
+        }
+    }
+} 

custom_components/ai_agent_ha/translations/en.txt

@@ -0,0 +1,81 @@
+{
+    "config": {
+        "step": {
+            "user": {
+                "title": "AI Agent HA - Select Provider",
+                "description": "Choose your AI provider",
+                "data": {
+                    "ai_provider": "AI Provider"
+                },
+                "data_description": {
+                    "ai_provider": "Select your preferred AI provider"
+                }
+            },
+            "configure": {
+                "title": "AI Agent HA - Configure {provider}",
+                "description": "Configure your {provider} API credentials and model",
+                "data": {
+                    "llama_token": "Llama API Token",
+                    "openai_token": "OpenAI API Key",
+                    "gemini_token": "Google Gemini API Key",
+                    "openrouter_token": "OpenRouter API Key",
+                    "model": "Model (Optional)",
+                    "custom_model": "Custom Model Name (Optional)"
+                },
+                "data_description": {
+                    "llama_token": "Enter your Llama API token",
+                    "openai_token": "Enter your OpenAI API key",
+                    "gemini_token": "Enter your Google Gemini API key",
+                    "openrouter_token": "Enter your OpenRouter API key",
+                    "model": "Choose a predefined model or select 'Custom...' to use a custom model",
+                    "custom_model": "Enter a custom model name (overrides the dropdown selection above)"
+                }
+            }
+        },
+        "error": {
+            "invalid_api_key": "Invalid API key or token",
+            "llama_token": "Llama API token is required",
+            "openai_token": "OpenAI API key is required",
+            "gemini_token": "Google Gemini API key is required",
+            "openrouter_token": "OpenRouter API key is required",
+            "unknown": "Unexpected error occurred"
+        },
+        "abort": {
+            "already_configured": "AI Agent HA is already configured"
+        }
+    },
+    "options": {
+        "step": {
+            "init": {
+                "title": "AI Agent HA - Select Provider",
+                "description": "Choose your AI provider (Current: {current_provider})",
+                "data": {
+                    "ai_provider": "AI Provider"
+                },
+                "data_description": {
+                    "ai_provider": "Select your preferred AI provider"
+                }
+            },
+            "configure_options": {
+                "title": "AI Agent HA - Configure {provider}",
+                "description": "Update your {provider} API credentials and model",
+                "data": {
+                    "llama_token": "Llama API Token",
+                    "openai_token": "OpenAI API Key",
+                    "gemini_token": "Google Gemini API Key",
+                    "openrouter_token": "OpenRouter API Key",
+                    "model": "Model (Optional)",
+                    "custom_model": "Custom Model Name (Optional)"
+                },
+                "data_description": {
+                    "llama_token": "Enter your Llama API token",
+                    "openai_token": "Enter your OpenAI API key",
+                    "gemini_token": "Enter your Google Gemini API key",
+                    "openrouter_token": "Enter your OpenRouter API key",
+                    "model": "Choose a predefined model or select 'Custom...' to use a custom model",
+                    "custom_model": "Enter a custom model name (overrides the dropdown selection above)"
+                }
+            }
+        }
+    }
+} 

custom_components/ai_agent_ha/translations/es.json

@@ -0,0 +1,81 @@
+{
+    "config": {
+        "step": {
+            "user": {
+                "title": "Agente de IA HA - Seleccionar proveedor",
+                "description": "Elige tu proveedor de IA",
+                "data": {
+                    "ai_provider": "Proveedor de IA"
+                },
+                "data_description": {
+                    "ai_provider": "Selecciona tu proveedor de IA preferido"
+                }
+            },
+            "configure": {
+                "title": "Agente de IA HA - Configurar {provider}",
+                "description": "Configura tus credenciales de API y modelo de {provider}",
+                "data": {
+                    "llama_token": "Token de la API de Llama",
+                    "openai_token": "Clave de la API de OpenAI",
+                    "gemini_token": "Clave de la API de Google Gemini",
+                    "openrouter_token": "Clave de la API de OpenRouter",
+                    "model": "Modelo (Opcional)",
+                    "custom_model": "Nombre de modelo personalizado (Opcional)"
+                },
+                "data_description": {
+                    "llama_token": "Introduce tu token de la API de Llama",
+                    "openai_token": "Introduce tu clave de la API de OpenAI",
+                    "gemini_token": "Introduce tu clave de la API de Google Gemini",
+                    "openrouter_token": "Introduce tu clave de la API de OpenRouter",
+                    "model": "Elige un modelo predefinido o selecciona 'Personalizado...' para usar un modelo personalizado",
+                    "custom_model": "Introduce un nombre de modelo personalizado (anula la selección desplegable anterior)"
+                }
+            }
+        },
+        "error": {
+            "invalid_api_key": "Clave o token de API no válido",
+            "llama_token": "Se requiere el token de la API de Llama",
+            "openai_token": "Se requiere la clave de la API de OpenAI",
+            "gemini_token": "Se requiere la clave de la API de Google Gemini",
+            "openrouter_token": "Se requiere la clave de la API de OpenRouter",
+            "unknown": "Ha ocurrido un error inesperado"
+        },
+        "abort": {
+            "already_configured": "El Agente de IA HA ya está configurado"
+        }
+    },
+    "options": {
+        "step": {
+            "init": {
+                "title": "Agente de IA HA - Seleccionar proveedor",
+                "description": "Elige tu proveedor de IA (Actual: {current_provider})",
+                "data": {
+                    "ai_provider": "Proveedor de IA"
+                },
+                "data_description": {
+                    "ai_provider": "Selecciona tu proveedor de IA preferido"
+                }
+            },
+            "configure_options": {
+                "title": "Agente de IA HA - Configurar {provider}",
+                "description": "Actualiza tus credenciales de API y modelo de {provider}",
+                "data": {
+                    "llama_token": "Token de la API de Llama",
+                    "openai_token": "Clave de la API de OpenAI",
+                    "gemini_token": "Clave de la API de Google Gemini",
+                    "openrouter_token": "Clave de la API de OpenRouter",
+                    "model": "Modelo (Opcional)",
+                    "custom_model": "Nombre de modelo personalizado (Opcional)"
+                },
+                "data_description": {
+                    "llama_token": "Introduce tu token de la API de Llama",
+                    "openai_token": "Introduce tu clave de la API de OpenAI",
+                    "gemini_token": "Introduce tu clave de la API de Google Gemini",
+                    "openrouter_token": "Introduce tu clave de la API de OpenRouter",
+                    "model": "Elige un modelo predefinido o selecciona 'Personalizado...' para usar un modelo personalizado",
+                    "custom_model": "Introduce un nombre de modelo personalizado (anula la selección desplegable anterior)"
+                }
+            }
+        }
+    }
+}