Fix: Resolve get_history service parameter handling issue

- Fixed async_get_history method to accept limit parameter and other filtering options - Updated service schema to support all parameters from services.yaml - Added support for start_date, include_metadata, and sort_order parameters - Version bump to 2.1.9
Update HACS minimum HA version to align with README requirement (2024.12.0)
2026-07-22 07:03:58 +08:00 · 2025-09-02 23:27:34 +03:00 · 2025-09-02 23:15:01 +03:00 · 2025-09-02 09:36:46 +03:00 · 2025-09-02 09:24:35 +03:00 · 2025-09-02 09:18:15 +03:00
23 changed files with 1005 additions and 214 deletions
@@ -1,5 +1,6 @@
 name: Validate with hassfest
-
+permissions:
+  contents: read
 on:
  push:
    branches:
@@ -1,4 +1,6 @@
 name: Validate
+permissions:
+  contents: read

 on:
  push:
@@ -1,41 +0,0 @@
-# Python
-__pycache__/
-*.py[cod]
-*$py.class
-*.so
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-
-# Home Assistant
-.storage
-.cloud
-.google.token
-
-# IDE
-.idea/
-.vscode/
-*.swp
-*.swo
-*~
-
-# OS
-.DS_Store
-Thumbs.db
-*.psd
-*.zip
-*.txt
-*.pdf
@@ -2,32 +2,33 @@

 <div align="center">  

-  ![GitHub release](https://img.shields.io/github/release/smkrv/ha-text-ai.svg?style=flat-square) ![GitHub last commit](https://img.shields.io/github/last-commit/smkrv/ha-text-ai.svg?style=flat-square) [![License: CC BY-NC-SA 4.0](https://img.shields.io/badge/License-CC%20BY--NC--SA%204.0-lightgrey.svg?style=flat-square)](https://creativecommons.org/licenses/by-nc-sa/4.0/) [![hacs_badge](https://img.shields.io/badge/HACS-Custom-41BDF5.svg?style=flat-square)](https://github.com/hacs/integration)  
-![Deutsch](https://img.shields.io/badge/de-Deutsch-blue?style=flat-square) ![English](https://img.shields.io/badge/en-English-blue?style=flat-square) ![Español](https://img.shields.io/badge/es-Español-blue?style=flat-square) ![हिन्दी](https://img.shields.io/badge/hi-हिन्दी-blue?style=flat-square) ![Italiano](https://img.shields.io/badge/it-Italiano-blue?style=flat-square) ![Русский](https://img.shields.io/badge/ru-Русский-blue?style=flat-square) ![Српски](https://img.shields.io/badge/sr-Српски-blue?style=flat-square) ![中文](https://img.shields.io/badge/zh-中文-blue?style=flat-square)
+  ![GitHub release](https://img.shields.io/github/v/release/smkrv/ha-text-ai?style=flat-square) ![GitHub last commit](https://img.shields.io/github/last-commit/smkrv/ha-text-ai?style=flat-square) [![License: CC BY-NC-SA 4.0](https://img.shields.io/badge/License-CC%20BY--NC--SA%204.0-lightgrey.svg?style=flat-square)](https://creativecommons.org/licenses/by-nc-sa/4.0/) [![hacs_badge](https://img.shields.io/badge/HACS-Default-41BDF5.svg?style=flat-square)](https://github.com/hacs/integration)
+  ![Deutsch](https://img.shields.io/badge/lang-DE-blue?style=flat-square) ![English](https://img.shields.io/badge/lang-EN-blue?style=flat-square) ![Español](https://img.shields.io/badge/lang-ES-blue?style=flat-square) ![हिन्दी](https://img.shields.io/badge/lang-HI-blue?style=flat-square) ![Italiano](https://img.shields.io/badge/lang-IT-blue?style=flat-square) ![Русский](https://img.shields.io/badge/lang-RU-blue?style=flat-square) ![Српски](https://img.shields.io/badge/lang-SR-blue?style=flat-square) ![中文](https://img.shields.io/badge/lang-ZH-blue?style=flat-square)


-  <img src="https://github.com/smkrv/ha-text-ai/blob/15c717fcb0204bf4a0d4b4b4c6f0bb93e9f6c9a9/custom_components/ha_text_ai/icons/logo%402x.png" alt="HA Text AI" style="width: 50%; max-width: 256px; max-height: 128px; aspect-ratio: 2/1; object-fit: contain;"/>
+  <img src="https://github.com/smkrv/ha-text-ai/blob/main/custom_components/ha_text_ai/icons/logo%402x.png" alt="HA Text AI" style="width: 50%; max-width: 256px; max-height: 128px; aspect-ratio: 2/1; object-fit: contain;"/>

 ### Advanced AI Integration for [Home Assistant](https://www.home-assistant.io/) with LLM multi-provider support
 </div>

 <p align="center">
-Transform your smart home experience with powerful AI assistance powered by multiple AI providers including OpenAI GPT and Anthropic Claude models. Get intelligent responses, automate complex scenarios, and enhance your home automation with advanced natural language processing.
+Transform your smart home experience with powerful AI assistance powered by multiple AI providers including OpenAI GPT, DeepSeek and Anthropic Claude models. Get intelligent responses, automate complex scenarios, and enhance your home automation with advanced natural language processing.

 </p>

 ---

 > [!IMPORTANT]
-> 🤝 Community Driven  
+> 🤝 Community Driven: for more details on the integration,   
+> check out the discussion on the **[Home Assistant Community forum](https://community.home-assistant.io/t/ha-text-ai-transforming-home-automation-through-multi-llm-integration/799741)**
 >
->  <a href="https://community.home-assistant.io/t/ha-text-ai-transforming-home-automation-with-multi-provider-language-models/799741"><img src="https://img.shields.io/badge/Community-blue?style=for-the-badge&logo=homeassistant&logoColor=white&color=03a9f4"/></a>  
+>  <a href="https://my.home-assistant.io/redirect/hacs_repository/?owner=smkrv&repository=ha-text-ai&category=Integration"><img src="https://my.home-assistant.io/badges/hacs_repository.svg" width="210" height="auto"></a>
 >  
 > [Screenshots](assets/images/screenshots/screenshot.jpg)

 ## 🌟 Features

- 🧠 **Multi-Provider AI Integration**: Support for OpenAI GPT and Anthropic Claude models
+- 🧠 **Multi-Provider AI Integration**: Support for OpenAI GPT, DeepSeek and Anthropic Claude models
 - 💬 **Advanced Language Processing**: Context-aware, multi-turn conversations
 - 📝 **Enhanced Memory Management**: Secure file-based history storage
 - ⚡ **Performance Optimization**: Efficient token usage and smart rate limiting
@@ -42,6 +43,7 @@ Transform your smart home experience with powerful AI assistance powered by mult
 ### 🧠 **Multi-Provider AI Integration**
 - Support for OpenAI GPT models
 - Anthropic Claude integration
+- DeepSeek integration
 - Custom API endpoints
 - Flexible model selection

@@ -104,12 +106,13 @@ Transform your smart home experience with powerful AI assistance powered by mult

 ## 📋 Prerequisites

- Home Assistant 2024.11 or later
+- Home Assistant 2024.12.0 or later (recommended for best compatibility)
 - Active API key from:
  - OpenAI ([Get key](https://platform.openai.com/account/api-keys))
  - Anthropic ([Get key](https://console.anthropic.com/))
-  - DeepSeek 🆕 ([Get key](https://platform.deepseek.com/api_keys)) 
+  - DeepSeek ([Get key](https://platform.deepseek.com/api_keys))
  - OpenRouter ([Get key](https://openrouter.ai/keys))
+  - Google Gemini 🆕 ([Get key](https://ai.google.dev/gemini-api/docs/api-key)) thanks to ([@Azzedde](https://github.com/Azzedde))
  - Any OpenAI-compatible API provider
 - Python 3.9 or newer
 - Stable internet connection
@@ -117,7 +120,7 @@ Transform your smart home experience with powerful AI assistance powered by mult
 ## Configuration Options

 ### 🔧 **Core Configuration Settings**
- 🌐 **API Provider**: OpenAI/Anthropic
+- 🌐 **API Provider**: OpenAI/Anthropic/DeepSeek/Gemini
 - 🔑 **API Key**: Provider-specific authentication
 - 🤖 **Model Selection**: Flexible, provider-specific models
 - 🌡️ **Temperature**: Creativity control (0.0-2.0)
@@ -126,6 +129,25 @@ Transform your smart home experience with powerful AI assistance powered by mult
 - 💾 **History Size**: Number of messages to retain
 - 🌍 **Custom API Endpoint**: Optional advanced configuration

+### 🤖 **Recommended Models**
+
+#### OpenAI Models
+- **GPT-5** - The latest flagship model, best for complex reasoning
+- **GPT-5 mini** - A cost-effective and fast model, suitable for most tasks
+
+#### Anthropic Claude Models  
+- **Claude Opus 4.1** - The most capable model for handling complex tasks
+- **Claude Sonnet 4** - Offers a balance between performance and cost
+- **Claude Haiku 4** - The fastest and most economical option in the series
+
+#### DeepSeek Models
+- **DeepSeek-V3.1** - A general-purpose model for a wide range of tasks
+- **DeepSeek-R1** - A specialized model focused on reasoning and coding
+
+#### Google Gemini Models
+- **Gemini 2.5 Pro & 2.5 Flash** - The newest and most advanced models available
+- **Gemini 2.0 Pro & 2.0 Flash** - Previous generation models that are still powerful and efficient
+
 <details>
 <summary>🌐 Potentially Compatible Providers</summary>

@@ -157,17 +179,23 @@ To be compatible, a provider should support:
 ## ⚡ Installation

 ### HACS Installation (Recommended)
+>[!TIP]
+>HA Text AI is available in the default HACS repository. You can install it directly through HACS or click the button below to open it there.
+
 <a href="https://my.home-assistant.io/redirect/hacs_repository/?owner=smkrv&repository=ha-text-ai&category=Integration"><img src="https://my.home-assistant.io/badges/hacs_repository.svg" width="170" height="auto"></a>
 1. Open HACS in Home Assistant
 2. Click on "Integrations"
-3. Click "..." in top right corner
-4. Select "Custom repositories"
-5. Add repository URL: `https://github.com/smkrv/ha-text-ai`
-6. Choose "Integration" as category
-7. Click "Download"
-8. Restart Home Assistant
+3. Search for "HA Text AI"
+4. Click "Download"
+5. Restart Home Assistant

-Note: Also Integration has been submitted to HACS store and is currently pending review in [pull request #2896](https://github.com/hacs/default/pull/2896).
+**Alternative Method (Custom Repository):**
+If the integration is not found in the default repository:
+1. Click "..." in top right corner of HACS
+2. Select "Custom repositories"
+3. Add repository URL: `https://github.com/smkrv/ha-text-ai`
+4. Choose "Integration" as category
+5. Click "Download"

 ### Manual Installation
 1. Download the latest release
@@ -192,7 +220,7 @@ Note: Also Integration has been submitted to HACS store and is currently pending
 ha_text_ai:
  api_provider: openai  # Required
  api_key: !secret ai_api_key  # Required
-  model: gpt-4o-mini  # Strongly recommended
+  model: gpt-4o  # Strongly recommended
  temperature: 0.7  # Optional
  max_tokens: 1000  # Optional
  request_interval: 1.0  # Optional
@@ -209,7 +237,7 @@ sensor:
  - platform: ha_text_ai
    name: "My AI Assistant"  # Required, unique identifier
    api_provider: openai  # Optional (inherits from platform)
-    model: "gpt-4o-mini"  # Optional
+    model: "gpt-4o"  # Optional
    temperature: 0.7  # Optional
    max_tokens: 1000  # Optional
 ```
@@ -220,16 +248,16 @@ sensor:

 | Parameter | Type | Required | Default | Description |
 |-----------|------|----------|---------|-------------|
-| `api_provider` | String | ✅ | - | AI service provider (openai, anthropic) |
+| `api_provider` | String | ✅ | - | AI service provider (openai, anthropic, deepseek, gemini) |
 | `api_key` | String | ✅ | - | Authentication key for AI service |
-| `model` | String | ⚠️ | Provider default | Strongly recommended: Specific AI model to use. If not specified, the provider's default model will be used |
-| `temperature` | Float | ❌ | 0.7 | Response creativity level (0.0-2.0) |
+| `model` | String | ⚠️ | gpt-4o-mini | Strongly recommended: Specific AI model to use. Default varies by provider |
+| `temperature` | Float | ❌ | 0.1 | Response creativity level (0.0-2.0) |
 | `max_tokens` | Integer | ❌ | 1000 | Maximum response length |
 | `request_interval` | Float | ❌ | 1.0 | Delay between API requests |
 | `api_endpoint` | URL | ⚠️ | Provider default | Custom API endpoint |
 | `system_prompt` | String | ❌ | - | Default context for AI interactions |
-| `max_history_size` | Integer | ❌ | 100 | Maximum number of conversation entries to store |
-| `history_file_size` | Integer | ⚠️  | 1 | Maximum history file size in MB |
+| `max_history_size` | Integer | ❌ | 50 | Maximum number of conversation entries to store |
+| `context_messages` | Integer | ❌ | 5 | Number of previous messages to include in context (1-20) |

 #### Sensor Configuration

@@ -238,25 +266,51 @@ sensor:
 | `platform` | String | ✅ | - | Must be `ha_text_ai` |
 | `name` | String | ✅ | - | Unique sensor identifier |
 | `api_provider` | String | ❌ | Platform setting | Override global provider |
-| `model` | String | ⚠️ | Platform setting | Recommended: Override global model. If not specified, uses platform or provider default |
-| `temperature` | Float | ❌ | Platform setting | Override global temperature |
-| `max_tokens` | Integer | ❌ | Platform setting | Override global max tokens |
+| `model` | String | ⚠️ | Provider default | Recommended: Override global model (gpt-4o-mini, deepseek-chat, gemini-2.0-flash) |
+| `temperature` | Float | ❌ | 0.1 | Override global temperature |
+| `max_tokens` | Integer | ❌ | 1000 | Override global max tokens |

 </details>

 ## 🛠️ Available Services

+### 🔄 Response Variables (New!)
+
+**HA Text AI now supports response variables** - a powerful feature that returns AI responses directly from service calls, eliminating the need for separate text sensors and the 255-character limitation!
+
+#### ✨ Key Benefits:
+- **Unlimited response length** - No more 255-character truncation
+- **Direct data access** - Get responses immediately in automations
+- **Race condition prevention** - Eliminates conflicts in parallel automations
+- **Simplified workflows** - No need to read from sensors
+
 ### ask_question
 ```yaml
 service: ha_text_ai.ask_question
 data:
  question: "What's the optimal temperature for sleeping?"
-  model: "claude-3-sonnet"  # optional
+  model: "claude-3.5-sonnet"  # optional
  temperature: 0.5  # optional
  max_tokens: 500  # optional
  context_messages: 10  #optional, number of previous messages to include in context, default: 5
  system_prompt: "You are a sleep optimization expert"  # optional
  instance: sensor.ha_text_ai_gpt
+response_variable: ai_response  # NEW! Store response data directly
+```
+
+#### 📊 Response Data Structure:
+```yaml
+# The service returns structured data:
+response_text: "The optimal sleeping temperature is 65-68°F (18-20°C)..."
+tokens_used: 150
+prompt_tokens: 50
+completion_tokens: 100
+model_used: "claude-3.5-sonnet"
+instance: "sensor.ha_text_ai_gpt"
+question: "What's the optimal temperature for sleeping?"
+timestamp: "2025-02-09T16:57:00.000Z"
+success: true
+# error: "Error message" (only present if success: false)
 ```

 ### set_system_prompt
@@ -283,11 +337,157 @@ data:
 ```yaml
 service: ha_text_ai.get_history
 data:
-  limit: 5  # optional
-  filter_model: "gpt-4o"  # optional
+  limit: 5  # optional, number of conversations to return (1-100)
+  filter_model: "gpt-4o"  # optional, filter by specific AI model
+  start_date: "2025-02-01"  # optional, filter conversations from this date
+  include_metadata: false  # optional, include tokens, response time, etc.
+  sort_order: "newest"  # optional, sort order: "newest" or "oldest"
  instance: sensor.ha_text_ai_gpt
 ```

+## 🚀 Advanced Automation Examples with Response Variables
+
+### Example 1: Smart Home Advice with Direct Response
+```yaml
+automation:
+  - alias: "Get AI Home Advice"
+    trigger:
+      - platform: state
+        entity_id: input_button.ask_ai_advice
+    action:
+      - service: ha_text_ai.ask_question
+        data:
+          question: "What's the best way to optimize energy usage in my home?"
+          instance: sensor.ha_text_ai_gpt
+        response_variable: ai_advice
+      - service: notify.mobile_app
+        data:
+          title: "🏠 Smart Home Tip"
+          message: |
+            {{ ai_advice.response_text }}
+            
+            📊 Tokens used: {{ ai_advice.tokens_used }}
+            🤖 Model: {{ ai_advice.model_used }}
+```
+
+### Example 2: Weather-Based AI Recommendations
+```yaml
+automation:
+  - alias: "Weather-Based AI Suggestions"
+    trigger:
+      - platform: numeric_state
+        entity_id: sensor.outdoor_temperature
+        below: 0
+    action:
+      - service: ha_text_ai.ask_question
+        data:
+          question: |
+            The outdoor temperature is {{ states('sensor.outdoor_temperature') }}°C. 
+            What should I do to prepare my home for freezing weather?
+          system_prompt: "You are a home maintenance expert. Provide practical, actionable advice."
+          instance: sensor.ha_text_ai_gpt
+        response_variable: winter_advice
+      - if:
+          - condition: template
+            value_template: "{{ winter_advice.success }}"
+        then:
+          - service: persistent_notification.create
+            data:
+              title: "❄️ Winter Preparation Advice"
+              message: |
+                {{ winter_advice.response_text }}
+                
+                Generated at: {{ winter_advice.timestamp }}
+        else:
+          - service: persistent_notification.create
+            data:
+              title: "⚠️ AI Service Error"
+              message: "Failed to get winter advice: {{ winter_advice.error }}"
+```
+
+### Example 3: Multi-Step AI Workflow
+```yaml
+automation:
+  - alias: "Multi-Step AI Analysis"
+    trigger:
+      - platform: state
+        entity_id: input_button.analyze_home_status
+    action:
+      # Step 1: Get current status analysis
+      - service: ha_text_ai.ask_question
+        data:
+          question: |
+            Current home status:
+            - Temperature: {{ states('sensor.indoor_temperature') }}°C
+            - Humidity: {{ states('sensor.indoor_humidity') }}%
+            - Energy usage: {{ states('sensor.power_consumption') }}W
+            
+            Analyze this data and provide insights.
+          instance: sensor.ha_text_ai_gpt
+        response_variable: status_analysis
+      
+      # Step 2: Get recommendations based on analysis
+      - service: ha_text_ai.ask_question
+        data:
+          question: |
+            Based on this analysis: "{{ status_analysis.response_text[:500] }}"
+            
+            Provide 3 specific actionable recommendations for improvement.
+          context_messages: 2  # Include previous conversation
+          instance: sensor.ha_text_ai_gpt
+        response_variable: recommendations
+      
+      # Step 3: Send comprehensive report
+      - service: notify.telegram
+        data:
+          title: "🏠 Home Analysis Report"
+          message: |
+            **Analysis:**
+            {{ status_analysis.response_text }}
+            
+            **Recommendations:**
+            {{ recommendations.response_text }}
+            
+            **Report Details:**
+            - Total tokens used: {{ status_analysis.tokens_used + recommendations.tokens_used }}
+            - Analysis model: {{ status_analysis.model_used }}
+            - Generated: {{ recommendations.timestamp }}
+```
+
+### 💡 Migration from Sensors to Response Variables
+
+#### Old Method (Limited):
+```yaml
+# ❌ Old way - limited to 255 characters, race conditions
+automation:
+  - alias: "Old AI Response Method"
+    action:
+      - service: ha_text_ai.ask_question
+        data:
+          question: "Long question here..."
+          instance: sensor.ha_text_ai_gpt
+      - delay: "00:00:05"  # Wait for sensor update
+      - service: notify.mobile
+        data:
+          message: "{{ state_attr('sensor.ha_text_ai_gpt', 'response')[:255] }}..."  # Truncated!
+```
+
+#### New Method (Unlimited):
+```yaml
+# ✅ New way - unlimited length, immediate access, no race conditions
+automation:
+  - alias: "New AI Response Method"
+    action:
+      - service: ha_text_ai.ask_question
+        data:
+          question: "Long question here..."
+          instance: sensor.ha_text_ai_gpt
+        response_variable: ai_response  # Direct access!
+      - service: notify.mobile
+        data:
+          message: "{{ ai_response.response_text }}"  # Full response, no truncation!
+```
+
 ### 🏷️ HA Text AI Sensor Naming Convention

 #### Character Restrictions  
@@ -453,10 +653,10 @@ Conversation history stored in `.storage/ha_text_ai_history/` directory:
 ## 📘 FAQ

 **Q: Which AI providers are supported?**
-A: Currently OpenAI (GPT models) and Anthropic (Claude models) are supported, with more providers planned.
+A: OpenAI (GPT models), Anthropic (Claude models), DeepSeek, Google Gemini, and OpenRouter are officially supported, with many other OpenAI-compatible providers working as well.

 **Q: How can I reduce API costs?**
-A: Use GPT-3.5-Turbo or Claude-3-Sonnet for most queries, implement caching, and optimize token usage.
+A: Use gpt-4o-mini or claude-3.5-haiku for most queries, implement caching, and optimize token usage.

 **Q: Are there limitations on the number of requests?**
 A: Depends on your API provider's plan. We recommend monitoring usage and implementing request throttling via `request_interval` configuration.
@@ -467,8 +667,11 @@ A: Yes, you can configure custom endpoints and use any compatible model by speci
 **Q: How do I switch between different AI providers?**
 A: Simply change the model parameter in your configuration or service calls to use the desired provider's model.

-**Q: How can I reduce API costs?**
-A: Use GPT-3.5-Turbo for most queries, implement caching, and optimize token usage.
+**Q: What are the token limits for different models?**
+A: Token limits vary by provider and model. OpenAI's gpt-4o supports up to 128K tokens, Claude 3.5 Sonnet supports up to 200K tokens, while smaller models typically have 8K-32K limits. Check your provider's documentation for specific limits.
+
+**Q: How do I monitor token usage?**
+A: Use the sensor attributes like `Total tokens`, `Prompt tokens`, and `Completion tokens` to track usage. You can also create automations to alert you when usage exceeds certain thresholds.

 **Q: Is my data secure?**
 A: Yes, your data is secure. The system operates entirely on your local machine, keeping your data under your control. API keys are stored securely and all external communications use encrypted connections.
@@ -534,8 +737,7 @@ If you want to say thanks financially, you can send a small token of appreciatio
 <div align="center"><img src="https://github.com/smkrv/ha-text-ai/blob/2aaf3405759eb2d97624834594e24ace896131df/assets/images/icons/footer_icon.png" alt="HA Text AI" style="width: 128px; height: auto;"/></div>  
 <div align="center">

-Made with ❤️ for the Home Assistant Community,  
-utilizing Claude 3.5 Sonnet, Gemini Pro 1.5, and Qwen 2.5 Coder 32B Instruct.
+Made with ❤️ for the Home Assistant Community

 [Report Bug](https://github.com/smkrv/ha-text-ai/issues) · [Request Feature](https://github.com/smkrv/ha-text-ai/issues)

@@ -0,0 +1,148 @@
+# Using response_variable with HA Text AI
+
+After updating the HA Text AI integration, it now supports using the `response_variable` parameter in Home Assistant scripts and automations.
+
+## What Changed
+
+- Added response schema support in the `ha_text_ai.ask_question` service
+- Service is now correctly registered with `supports_response=True` flag
+- You can now use `response_variable` to capture AI response in a variable
+
+## Example Usage in Script
+
+```yaml
+action: ha_text_ai.ask_question
+data:
+  context_messages: 0
+  temperature: 0.7
+  max_tokens: 1000
+  instance: sensor.ha_text_ai_gemini
+  question: "What time is it?"
+response_variable: ai_response
+```
+
+## Example Usage in Automation
+
+```yaml
+alias: "Get AI Response"
+trigger:
+  - platform: state
+    entity_id: input_boolean.ask_ai
+    to: "on"
+action:
+  - action: ha_text_ai.ask_question
+    data:
+      instance: sensor.ha_text_ai_gemini
+      question: "What's the current weather?"
+      temperature: 0.7
+      max_tokens: 500
+    response_variable: weather_response
+  
+  - action: notify.persistent_notification
+    data:
+      title: "AI Response"
+      message: "{{ weather_response.response_text }}"
+```
+
+## Available Fields in response_variable
+
+When you use `response_variable`, you will receive an object with the following fields:
+
+- `response_text` (string) - The AI response text
+- `tokens_used` (integer) - Total number of tokens used
+- `prompt_tokens` (integer) - Number of tokens in the prompt
+- `completion_tokens` (integer) - Number of tokens in the completion
+- `model_used` (string) - The AI model that was used for the response
+- `instance` (string) - The instance name that was used
+- `question` (string) - The original question that was asked
+- `timestamp` (string) - ISO timestamp when the response was generated
+- `success` (boolean) - Whether the request was successful
+- `error` (string) - Error message if the request failed
+
+## Example Using Response Fields
+
+```yaml
+action:
+  - action: ha_text_ai.ask_question
+    data:
+      instance: sensor.ha_text_ai_gemini
+      question: "Tell me a joke"
+    response_variable: joke_response
+  
+  - condition: template
+    value_template: "{{ joke_response.success }}"
+  
+  - action: input_text.set_value
+    target:
+      entity_id: input_text.last_ai_response
+    data:
+      value: "{{ joke_response.response_text }}"
+  
+  - action: input_number.set_value
+    target:
+      entity_id: input_number.tokens_used
+    data:
+      value: "{{ joke_response.tokens_used }}"
+```
+
+## Error Handling
+
+```yaml
+action:
+  - action: ha_text_ai.ask_question
+    data:
+      instance: sensor.ha_text_ai_gemini
+      question: "Test question"
+    response_variable: ai_result
+  
+  - choose:
+      - conditions:
+          - condition: template
+            value_template: "{{ ai_result.success }}"
+        sequence:
+          - action: notify.mobile_app_phone
+            data:
+              title: "AI Response"
+              message: "{{ ai_result.response_text }}"
+      - conditions:
+          - condition: template
+            value_template: "{{ not ai_result.success }}"
+        sequence:
+          - action: notify.mobile_app_phone
+            data:
+              title: "AI Error"
+              message: "Error: {{ ai_result.error }}"
+```
+
+## Migration from Old Approach
+
+**Old method (without response_variable):**
+```yaml
+# Ask question
+- action: ha_text_ai.ask_question
+  data:
+    instance: sensor.ha_text_ai_gemini
+    question: "Hello!"
+
+# Wait and read response from sensor
+- delay: 00:00:05
+- action: notify.mobile_app_phone
+  data:
+    message: "{{ states('sensor.ha_text_ai_gemini') }}"
+```
+
+**New method (with response_variable):**
+```yaml
+# Ask question and get response immediately
+- action: ha_text_ai.ask_question
+  data:
+    instance: sensor.ha_text_ai_gemini
+    question: "Hello!"
+  response_variable: greeting_response
+
+- action: notify.mobile_app_phone
+  data:
+    message: "{{ greeting_response.response_text }}"
+```
+
+The new approach is more reliable as it doesn't require waiting and reading from the sensor.
@@ -40,13 +40,16 @@ from .const import (
    API_PROVIDER_OPENAI,
    API_PROVIDER_ANTHROPIC,
    API_PROVIDER_DEEPSEEK,
+    API_PROVIDER_GEMINI,
    DEFAULT_MODEL,
    DEFAULT_DEEPSEEK_MODEL,
+    DEFAULT_GEMINI_MODEL,
    DEFAULT_TEMPERATURE,
    DEFAULT_MAX_TOKENS,
    DEFAULT_OPENAI_ENDPOINT,
    DEFAULT_ANTHROPIC_ENDPOINT,
    DEFAULT_DEEPSEEK_ENDPOINT,
+    DEFAULT_GEMINI_ENDPOINT,
    DEFAULT_REQUEST_INTERVAL,
    DEFAULT_CONTEXT_MESSAGES,
    API_TIMEOUT,
@@ -83,6 +86,9 @@ SERVICE_SCHEMA_GET_HISTORY = vol.Schema({
    vol.Required("instance"): cv.string,
    vol.Optional("limit"): cv.positive_int,
    vol.Optional("filter_model"): cv.string,
+    vol.Optional("start_date"): cv.string,
+    vol.Optional("include_metadata"): cv.boolean,
+    vol.Optional("sort_order"): vol.In(["newest", "oldest"]),
 })

 def get_coordinator_by_instance(hass: HomeAssistant, instance: str) -> HATextAICoordinator:
@@ -109,11 +115,11 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
    # Initialize domain data storage
    hass.data.setdefault(DOMAIN, {})

-    async def async_ask_question(call: ServiceCall) -> None:
-        """Handle ask_question service."""
+    async def async_ask_question(call: ServiceCall) -> dict:
+        """Handle ask_question service with response data."""
        try:
            coordinator = get_coordinator_by_instance(hass, call.data["instance"])
-            await coordinator.async_ask_question(
+            response = await coordinator.async_ask_question(
                question=call.data["question"],
                model=call.data.get("model"),
                temperature=call.data.get("temperature"),
@@ -121,9 +127,34 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
                system_prompt=call.data.get("system_prompt"),
                context_messages=call.data.get("context_messages"),
            )
+            
+            # Return structured response data
+            return {
+                "response_text": response.get("content", ""),
+                "tokens_used": response.get("tokens", {}).get("total", 0),
+                "prompt_tokens": response.get("tokens", {}).get("prompt", 0),
+                "completion_tokens": response.get("tokens", {}).get("completion", 0),
+                "model_used": response.get("model", call.data.get("model", coordinator.model)),
+                "instance": call.data["instance"],
+                "question": call.data["question"],
+                "timestamp": response.get("timestamp"),
+                "success": True
+            }
        except Exception as err:
            _LOGGER.error("Error asking question: %s", str(err))
-            raise HomeAssistantError(f"Failed to process question: {str(err)}")
+            # Return error response
+            return {
+                "response_text": "",
+                "tokens_used": 0,
+                "prompt_tokens": 0,
+                "completion_tokens": 0,
+                "model_used": call.data.get("model", ""),
+                "instance": call.data["instance"],
+                "question": call.data["question"],
+                "timestamp": datetime.now().isoformat(),
+                "success": False,
+                "error": str(err)
+            }

    async def async_clear_history(call: ServiceCall) -> None:
        """Handle clear_history service."""
@@ -140,7 +171,10 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
            coordinator = get_coordinator_by_instance(hass, call.data["instance"])
            return await coordinator.async_get_history(
                limit=call.data.get("limit"),
-                filter_model=call.data.get("filter_model")
+                filter_model=call.data.get("filter_model"),
+                start_date=call.data.get("start_date"),
+                include_metadata=call.data.get("include_metadata", False),
+                sort_order=call.data.get("sort_order", "newest")
            )
        except Exception as err:
            _LOGGER.error("Error getting history: %s", str(err))
@@ -160,7 +194,8 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
        DOMAIN,
        SERVICE_ASK_QUESTION,
        async_ask_question,
-        schema=SERVICE_SCHEMA_ASK_QUESTION
+        schema=SERVICE_SCHEMA_ASK_QUESTION,
+        supports_response=True
    )

    hass.services.async_register(
@@ -236,10 +271,17 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
 async def async_check_api(session, endpoint: str, headers: dict, provider: str) -> bool:
    """Check API availability for different providers."""
    try:
-        if provider == API_PROVIDER_ANTHROPIC:
+        if provider == API_PROVIDER_GEMINI:
+            # Gemini API does not support GET /models for validation, just check key presence
+            if headers.get("Authorization", "").replace("Bearer ", ""):
+                return True
+            else:
+                _LOGGER.error("Gemini API key is missing or empty")
+                return False
+        elif provider == API_PROVIDER_ANTHROPIC:
            check_url = f"{endpoint}/v1/models"
        elif provider == API_PROVIDER_DEEPSEEK:
-            check_url = f"{endpoint}/models"  # DeepSeek
+            check_url = f"{endpoint}/models"
        else:  # OpenAI
            check_url = f"{endpoint}/models"

@@ -248,7 +290,8 @@ async def async_check_api(session, endpoint: str, headers: dict, provider: str)
                if response.status in [200, 404]:
                    return True
                elif response.status == 401:
-                    raise ConfigEntryNotReady("Invalid API key")
+                    _LOGGER.error("Invalid API key")
+                    return False
                elif response.status == 429:
                    _LOGGER.warning("Rate limit exceeded during API check")
                    return False
@@ -11,6 +11,7 @@ import asyncio
 from typing import Any, Dict, List, Optional
 from aiohttp import ClientSession, ClientTimeout
 from async_timeout import timeout
+from datetime import datetime, timedelta

 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import HomeAssistantError
@@ -20,6 +21,7 @@ from .const import (
    API_PROVIDER_ANTHROPIC,
    API_PROVIDER_DEEPSEEK,
    API_PROVIDER_OPENAI,
+    API_PROVIDER_GEMINI,
    MIN_TEMPERATURE,
    MAX_TEMPERATURE,
    MIN_MAX_TOKENS,
@@ -47,20 +49,36 @@ class APIClient:
        self.api_provider = api_provider
        self.model = model
        self.timeout = ClientTimeout(total=API_TIMEOUT)
+        self._closed = False
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.shutdown()

    def _validate_parameters(
        self,
        temperature: float,
        max_tokens: int,
    ) -> None:
-        """Validate API parameters."""
+        """Validate API parameters with enhanced type checking."""
+        # Type validation
+        if not isinstance(temperature, (int, float)):
+            raise TypeError(f"Temperature must be a number, got {type(temperature)}")
+        if not isinstance(max_tokens, int):
+            raise TypeError(f"Max tokens must be an integer, got {type(max_tokens)}")
+            
+        # Range validation
        if not MIN_TEMPERATURE <= temperature <= MAX_TEMPERATURE:
            raise ValueError(
-                f"Temperature must be between {MIN_TEMPERATURE} and {MAX_TEMPERATURE}"
+                f"Temperature must be between {MIN_TEMPERATURE} and {MAX_TEMPERATURE}, got {temperature}"
            )
        if not MIN_MAX_TOKENS <= max_tokens <= MAX_MAX_TOKENS:
            raise ValueError(
-                f"Max tokens must be between {MIN_MAX_TOKENS} and {MAX_MAX_TOKENS}"
+                f"Max tokens must be between {MIN_MAX_TOKENS} and {MAX_MAX_TOKENS}, got {max_tokens}"
            )

    async def _make_request(
@@ -69,7 +87,10 @@ class APIClient:
        payload: Dict[str, Any],
    ) -> Dict[str, Any]:
        """Make API request with retry logic."""
-        _LOGGER.debug(f"API Request: URL={url}, Payload={payload}")
+        # Log request without sensitive data
+        safe_payload = {k: v for k, v in payload.items() if k not in ['messages', 'system']}
+        _LOGGER.debug(f"API Request: URL={url}, Safe payload: {safe_payload}")
+        
        for attempt in range(API_RETRY_COUNT):
            try:
                async with timeout(API_TIMEOUT):
@@ -82,16 +103,18 @@ class APIClient:
                        _LOGGER.debug(f"Response status: {response.status}")
                        if response.status != 200:
                            error_data = await response.json()
-                            _LOGGER.error(f"API error: {error_data}")
-                            raise HomeAssistantError(f"API error: {error_data}")
+                            # Log error without sensitive data
+                            safe_error = {k: v for k, v in error_data.items() if k not in ['message', 'details']}
+                            _LOGGER.error(f"API error (status {response.status}): {safe_error}")
+                            raise HomeAssistantError(f"API error: status {response.status}")
                        return await response.json()
            except asyncio.TimeoutError:
-                _LOGGER.warning(f"Timeout on attempt {attempt + 1}")
+                _LOGGER.warning(f"Timeout on attempt {attempt + 1}/{API_RETRY_COUNT}")
                if attempt == API_RETRY_COUNT - 1:
                    raise HomeAssistantError("API request timed out")
                await asyncio.sleep(1 * (attempt + 1))
            except Exception as e:
-                _LOGGER.warning(f"API request failed on attempt {attempt + 1}: {str(e)}")
+                _LOGGER.warning(f"API request failed on attempt {attempt + 1}/{API_RETRY_COUNT}: {type(e).__name__}")
                if attempt == API_RETRY_COUNT - 1:
                    raise
                await asyncio.sleep(1 * (attempt + 1))
@@ -115,6 +138,10 @@ class APIClient:
                return await self._create_deepseek_completion(
                    model, messages, temperature, max_tokens
                )
+            elif self.api_provider == API_PROVIDER_GEMINI:
+                return await self._create_gemini_completion(
+                    model, messages, temperature, max_tokens
+                )
            else:
                return await self._create_openai_completion(
                    model, messages, temperature, max_tokens
@@ -238,6 +265,143 @@ class APIClient:
            _LOGGER.error(f"Connection check failed: {str(e)}")
            return False

+    async def _create_gemini_completion(
+        self,
+        model: str,
+        messages: List[Dict[str, str]],
+        temperature: float,
+        max_tokens: int,
+    ) -> Dict[str, Any]:
+        """Create completion using Gemini API with google-genai library.
+
+        Args:
+            model: The model name to use
+            messages: List of message dictionaries with role and content
+            temperature: Sampling temperature between 0.0 and 2.0
+            max_tokens: Maximum number of tokens to generate
+
+        Returns:
+            Dictionary with response content and token usage
+        """
+        try:
+            def import_genai():
+                from google import genai
+                return genai
+
+            genai = await asyncio.to_thread(import_genai)
+
+            # Extract API key from headers (Bearer token)
+            api_key = self.headers.get("Authorization", "").replace("Bearer ", "")
+
+            def create_client():
+                if self.endpoint and self.endpoint != "https://generativelanguage.googleapis.com/v1beta":
+                    return genai.Client(api_key=api_key, transport="rest",
+                                       client_options={"api_endpoint": self.endpoint})
+                else:
+                    return genai.Client(api_key=api_key)
+
+            client = await asyncio.to_thread(create_client)
+
+            # Process messages to extract system instruction and chat history
+            system_instruction = ""
+            contents = []
+
+            for msg in messages:
+                if msg['role'] == 'system':
+                    system_instruction += msg['content'] + "\n"
+                else:
+                    # For chat history, we need to convert to the format Gemini expects
+                    role = "user" if msg['role'] == 'user' else "model"
+                    contents.append({
+                        "role": role,
+                        "parts": [{"text": msg['content']}]
+                    })
+
+            # Create configuration
+            def create_config():
+                from google.genai import types
+                config = types.GenerateContentConfig(
+                    temperature=temperature,
+                    max_output_tokens=max_tokens,
+                )
+
+                # Add system instruction if present
+                if system_instruction:
+                    config.system_instruction = system_instruction.strip()
+
+                return config
+
+            config = await asyncio.to_thread(create_config)
+
+            def generate_content():
+                # For single message without history, use generate_content
+                if len(contents) <= 1:
+                    # If we have no content yet, create a simple prompt
+                    if not contents:
+                        prompt = "I need your assistance."
+                    else:
+                        prompt = contents[0]["parts"][0]["text"]
+
+                    return client.models.generate_content(
+                        model=model,
+                        contents=prompt,
+                        config=config
+                    )
+                else:
+                    # For multi-turn conversations, use chat
+                    chat = client.chats.create(model=model, config=config)
+
+                    # Send all messages in sequence
+                    for content in contents:
+                        if content["role"] == "user":
+                            response = chat.send_message(content["parts"][0]["text"])
+                            # We don't send assistant messages as they're already part of the history
+
+                    return response
+
+            response = await asyncio.to_thread(generate_content)
+
+            # Extract response text
+            def extract_response():
+                response_text = response.text if hasattr(response, 'text') else ""
+
+                # Try to get token usage if available
+                usage = {}
+                if hasattr(response, 'usage_metadata'):
+                    usage = {
+                        "prompt_tokens": getattr(response.usage_metadata, 'prompt_token_count', 0),
+                        "completion_tokens": getattr(response.usage_metadata, 'candidates_token_count', 0),
+                        "total_tokens": getattr(response.usage_metadata, 'total_token_count', 0)
+                    }
+                else:
+                    # Estimate token count as fallback
+                    usage = {
+                        "prompt_tokens": len(" ".join([m["content"] for m in messages]).split()) // 3,
+                        "completion_tokens": len(response_text.split()) // 3,
+                        "total_tokens": 0  # Will be calculated below
+                    }
+                    usage["total_tokens"] = usage["prompt_tokens"] + usage["completion_tokens"]
+
+                return response_text, usage
+
+            response_text, usage = await asyncio.to_thread(extract_response)
+
+            return {
+                "choices": [{
+                    "message": {
+                        "content": response_text
+                    }
+                }],
+                "usage": usage
+            }
+
+        except ImportError as e:
+            _LOGGER.error(f"Google Gemini library not installed: {str(e)}")
+            raise HomeAssistantError(f"Missing dependency: {str(e)}. Please install google-genai.")
+        except Exception as e:
+            _LOGGER.error(f"Gemini API error: {str(e)}")
+            raise HomeAssistantError(f"Gemini API error: {str(e)}")
+
    async def shutdown(self) -> None:
        """Shutdown API client."""
        _LOGGER.debug("Shutting down API client")
@@ -8,6 +8,7 @@ Config flow for HA text AI integration.
 """
 import logging
 from typing import Any, Dict, Optional
+from datetime import datetime, timedelta

 import voluptuous as vol
 from homeassistant import config_entries
@@ -29,15 +30,18 @@ from .const import (
    API_PROVIDER_OPENAI,
    API_PROVIDER_ANTHROPIC,
    API_PROVIDER_DEEPSEEK,
+    API_PROVIDER_GEMINI,
    API_PROVIDERS,
    DEFAULT_MODEL,
    DEFAULT_DEEPSEEK_MODEL,
+    DEFAULT_GEMINI_MODEL,
    DEFAULT_TEMPERATURE,
    DEFAULT_MAX_TOKENS,
    DEFAULT_REQUEST_INTERVAL,
    DEFAULT_OPENAI_ENDPOINT,
    DEFAULT_ANTHROPIC_ENDPOINT,
    DEFAULT_DEEPSEEK_ENDPOINT,
+    DEFAULT_GEMINI_ENDPOINT,
    DEFAULT_CONTEXT_MESSAGES,
    MIN_TEMPERATURE,
    MAX_TEMPERATURE,
@@ -93,15 +97,20 @@ class HATextAIConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
        self._errors = {}

        if user_input is None:
-            # Выбор endpoint по провайдеру
+            # Selecting an endpoint by provider
            default_endpoint = {
                API_PROVIDER_OPENAI: DEFAULT_OPENAI_ENDPOINT,
                API_PROVIDER_ANTHROPIC: DEFAULT_ANTHROPIC_ENDPOINT,
                API_PROVIDER_DEEPSEEK: DEFAULT_DEEPSEEK_ENDPOINT,
+                API_PROVIDER_GEMINI: DEFAULT_GEMINI_ENDPOINT,
            }.get(self._provider, DEFAULT_OPENAI_ENDPOINT)

-            # Выбор модели по умолчанию по провайдеру
-            default_model = DEFAULT_DEEPSEEK_MODEL if self._provider == API_PROVIDER_DEEPSEEK else DEFAULT_MODEL
+            # Selecting the default model by provider
+            default_model = (
+                DEFAULT_DEEPSEEK_MODEL if self._provider == API_PROVIDER_DEEPSEEK else
+                DEFAULT_GEMINI_MODEL if self._provider == API_PROVIDER_GEMINI else
+                DEFAULT_MODEL
+            )

            return self.async_show_form(
                step_id="provider",
@@ -139,41 +148,173 @@ class HATextAIConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
                })
            )

+        # Debug log to identify what's in the input
+        _LOGGER.debug(f"Provider step input data: {user_input}")
+
        input_copy = user_input.copy()

+        # Check if CONF_NAME exists in input_copy and ensure it's not empty
+        if CONF_NAME not in input_copy or not input_copy[CONF_NAME]:
+            _LOGGER.warning(f"Missing name in configuration input: {input_copy}")
+            input_copy[CONF_NAME] = f"gemini_assistant_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
+            _LOGGER.info(f"Auto-generated name: {input_copy[CONF_NAME]}")
+
+        # Ensure API key is present
+        if CONF_API_KEY not in input_copy or not input_copy[CONF_API_KEY]:
+            self._errors["base"] = "invalid_auth"
+            _LOGGER.error("API validation error: 'api_key'")
+            return self.async_show_form(
+                step_id="provider",
+                data_schema=vol.Schema({
+                    vol.Required(CONF_NAME, default=input_copy.get(CONF_NAME, "my_assistant")): str,
+                    vol.Required(CONF_API_KEY): str,
+                    vol.Required(CONF_MODEL, default=input_copy.get(CONF_MODEL, DEFAULT_GEMINI_MODEL if self._provider == API_PROVIDER_GEMINI else DEFAULT_MODEL)): str,
+                    vol.Required(CONF_API_ENDPOINT, default=input_copy.get(CONF_API_ENDPOINT, DEFAULT_GEMINI_ENDPOINT if self._provider == API_PROVIDER_GEMINI else DEFAULT_OPENAI_ENDPOINT)): str,
+                    vol.Optional(CONF_TEMPERATURE, default=input_copy.get(CONF_TEMPERATURE, DEFAULT_TEMPERATURE)): vol.All(
+                        vol.Coerce(float),
+                        vol.Range(min=MIN_TEMPERATURE, max=MAX_TEMPERATURE)
+                    ),
+                    vol.Optional(CONF_MAX_TOKENS, default=input_copy.get(CONF_MAX_TOKENS, DEFAULT_MAX_TOKENS)): vol.All(
+                        vol.Coerce(int),
+                        vol.Range(min=MIN_MAX_TOKENS, max=MAX_MAX_TOKENS)
+                    ),
+                    vol.Optional(CONF_REQUEST_INTERVAL, default=input_copy.get(CONF_REQUEST_INTERVAL, DEFAULT_REQUEST_INTERVAL)): vol.All(
+                        vol.Coerce(float),
+                        vol.Range(min=MIN_REQUEST_INTERVAL)
+                    ),
+                    vol.Optional(
+                        CONF_CONTEXT_MESSAGES,
+                        default=input_copy.get(CONF_CONTEXT_MESSAGES, DEFAULT_CONTEXT_MESSAGES)
+                    ): vol.All(
+                        vol.Coerce(int),
+                        vol.Range(min=1, max=20)
+                    ),
+                    vol.Optional(
+                        CONF_MAX_HISTORY_SIZE,
+                        default=input_copy.get(CONF_MAX_HISTORY_SIZE, DEFAULT_MAX_HISTORY)
+                    ): vol.All(
+                        vol.Coerce(int),
+                        vol.Range(min=1, max=100)
+                    ),
+                }),
+                errors=self._errors
+            )
+
        try:
+            # Validate and normalize the name
            normalized_name = self._validate_and_normalize_name(input_copy[CONF_NAME])
            input_copy[CONF_NAME] = normalized_name
        except ValueError as e:
            return self.async_show_form(
                step_id="provider",
                data_schema=vol.Schema({
-                    vol.Required(CONF_NAME, default=input_copy[CONF_NAME]): str,
-                    vol.Required(CONF_API_KEY, default=input_copy[CONF_API_KEY]): str,
-                    vol.Required(CONF_MODEL, default=input_copy[CONF_MODEL]): str,
-                    vol.Required(CONF_API_ENDPOINT, default=input_copy[CONF_API_ENDPOINT]): str,
+                    vol.Required(CONF_NAME, default=input_copy.get(CONF_NAME, "my_assistant")): str,
+                    vol.Required(CONF_API_KEY, default=input_copy.get(CONF_API_KEY, "")): str,
+                    vol.Required(CONF_MODEL, default=input_copy.get(CONF_MODEL, DEFAULT_GEMINI_MODEL if self._provider == API_PROVIDER_GEMINI else DEFAULT_MODEL)): str,
+                    vol.Required(CONF_API_ENDPOINT, default=input_copy.get(CONF_API_ENDPOINT, DEFAULT_GEMINI_ENDPOINT if self._provider == API_PROVIDER_GEMINI else DEFAULT_OPENAI_ENDPOINT)): str,
                    vol.Optional(CONF_TEMPERATURE, default=input_copy.get(CONF_TEMPERATURE, DEFAULT_TEMPERATURE)): vol.All(
                        vol.Coerce(float),
                        vol.Range(min=MIN_TEMPERATURE, max=MAX_TEMPERATURE)
                    ),
+                    vol.Optional(CONF_MAX_TOKENS, default=input_copy.get(CONF_MAX_TOKENS, DEFAULT_MAX_TOKENS)): vol.All(
+                        vol.Coerce(int),
+                        vol.Range(min=MIN_MAX_TOKENS, max=MAX_MAX_TOKENS)
+                    ),
+                    vol.Optional(CONF_REQUEST_INTERVAL, default=input_copy.get(CONF_REQUEST_INTERVAL, DEFAULT_REQUEST_INTERVAL)): vol.All(
+                        vol.Coerce(float),
+                        vol.Range(min=MIN_REQUEST_INTERVAL)
+                    ),
+                    vol.Optional(
+                        CONF_CONTEXT_MESSAGES,
+                        default=input_copy.get(CONF_CONTEXT_MESSAGES, DEFAULT_CONTEXT_MESSAGES)
+                    ): vol.All(
+                        vol.Coerce(int),
+                        vol.Range(min=1, max=20)
+                    ),
+                    vol.Optional(
+                        CONF_MAX_HISTORY_SIZE,
+                        default=input_copy.get(CONF_MAX_HISTORY_SIZE, DEFAULT_MAX_HISTORY)
+                    ): vol.All(
+                        vol.Coerce(int),
+                        vol.Range(min=1, max=100)
+                    ),
                }),
                errors={"name": str(e)}
            )

        try:
-            if not await self._async_validate_api(input_copy):
-                return self.async_show_form(
-                    step_id="provider",
-                    data_schema=vol.Schema({}),
-                    errors=self._errors
-                )
+            # Special handling for Gemini API validation
+            if self._provider == API_PROVIDER_GEMINI:
+                # For Gemini, we just check if API key is present as there's no simple endpoint to validate
+                if not input_copy.get(CONF_API_KEY):
+                    self._errors["base"] = "invalid_auth"
+                    _LOGGER.error("API validation error: 'api_key'")
+                    return self.async_show_form(
+                        step_id="provider",
+                        data_schema=vol.Schema({
+                            vol.Required(CONF_NAME, default=input_copy.get(CONF_NAME, "my_assistant")): str,
+                            vol.Required(CONF_API_KEY): str,
+                            vol.Required(CONF_MODEL, default=input_copy.get(CONF_MODEL, DEFAULT_GEMINI_MODEL)): str,
+                            vol.Required(CONF_API_ENDPOINT, default=input_copy.get(CONF_API_ENDPOINT, DEFAULT_GEMINI_ENDPOINT)): str,
+                            # Other fields remain the same
+                        }),
+                        errors=self._errors
+                    )
+            else:
+                # For other providers, validate API connection
+                if not await self._async_validate_api(input_copy):
+                    return self.async_show_form(
+                        step_id="provider",
+                        data_schema=vol.Schema({
+                            vol.Required(CONF_NAME, default=input_copy.get(CONF_NAME, "my_assistant")): str,
+                            vol.Required(CONF_API_KEY, default=input_copy.get(CONF_API_KEY, "")): str,
+                            vol.Required(CONF_MODEL, default=input_copy.get(CONF_MODEL, DEFAULT_MODEL)): str,
+                            vol.Required(CONF_API_ENDPOINT, default=input_copy.get(CONF_API_ENDPOINT, DEFAULT_OPENAI_ENDPOINT)): str,
+                            vol.Optional(CONF_TEMPERATURE, default=input_copy.get(CONF_TEMPERATURE, DEFAULT_TEMPERATURE)): vol.All(
+                                vol.Coerce(float),
+                                vol.Range(min=MIN_TEMPERATURE, max=MAX_TEMPERATURE)
+                            ),
+                            vol.Optional(CONF_MAX_TOKENS, default=input_copy.get(CONF_MAX_TOKENS, DEFAULT_MAX_TOKENS)): vol.All(
+                                vol.Coerce(int),
+                                vol.Range(min=MIN_MAX_TOKENS, max=MAX_MAX_TOKENS)
+                            ),
+                            vol.Optional(CONF_REQUEST_INTERVAL, default=input_copy.get(CONF_REQUEST_INTERVAL, DEFAULT_REQUEST_INTERVAL)): vol.All(
+                                vol.Coerce(float),
+                                vol.Range(min=MIN_REQUEST_INTERVAL)
+                            ),
+                            vol.Optional(
+                                CONF_CONTEXT_MESSAGES,
+                                default=input_copy.get(CONF_CONTEXT_MESSAGES, DEFAULT_CONTEXT_MESSAGES)
+                            ): vol.All(
+                                vol.Coerce(int),
+                                vol.Range(min=1, max=20)
+                            ),
+                            vol.Optional(
+                                CONF_MAX_HISTORY_SIZE,
+                                default=input_copy.get(CONF_MAX_HISTORY_SIZE, DEFAULT_MAX_HISTORY)
+                            ): vol.All(
+                                vol.Coerce(int),
+                                vol.Range(min=1, max=100)
+                            ),
+                        }),
+                        errors=self._errors
+                    )
        except Exception as e:
+            # Handle any unexpected exceptions during validation
+            _LOGGER.exception("Unexpected error during API validation")
            return self.async_show_form(
                step_id="provider",
-                data_schema=vol.Schema({}),
+                data_schema=vol.Schema({
+                    vol.Required(CONF_NAME, default=input_copy.get(CONF_NAME, "my_assistant")): str,
+                    vol.Required(CONF_API_KEY, default=input_copy.get(CONF_API_KEY, "")): str,
+                    vol.Required(CONF_MODEL, default=input_copy.get(CONF_MODEL, DEFAULT_GEMINI_MODEL if self._provider == API_PROVIDER_GEMINI else DEFAULT_MODEL)): str,
+                    vol.Required(CONF_API_ENDPOINT, default=input_copy.get(CONF_API_ENDPOINT, DEFAULT_GEMINI_ENDPOINT if self._provider == API_PROVIDER_GEMINI else DEFAULT_OPENAI_ENDPOINT)): str,
+                    # Other fields remain the same
+                }),
                errors={"base": str(e)}
            )

+        # All validation passed, create the entry
        return await self._create_entry(input_copy)

    def _validate_and_normalize_name(self, name: str) -> str:
@@ -211,23 +352,34 @@ class HATextAIConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
    async def _async_validate_api(self, user_input: Dict[str, Any]) -> bool:
        """Validate API connection."""
        try:
+            if CONF_API_KEY not in user_input:
+                _LOGGER.error("API validation error: 'api_key'")
+                self._errors["base"] = "invalid_auth"
+                return False
+
            session = async_get_clientsession(self.hass)
            headers = self._get_api_headers(user_input)
            endpoint = user_input[CONF_API_ENDPOINT].rstrip('/')

-            check_url = (
-                f"{endpoint}/v1/models" if self._provider == API_PROVIDER_ANTHROPIC
-                else f"{endpoint}/models"
-            )
-
-            async with session.get(check_url, headers=headers) as response:
-                if response.status == 401:
+            if self._provider == API_PROVIDER_GEMINI:
+                if not user_input[CONF_API_KEY]:
                    self._errors["base"] = "invalid_auth"
                    return False
-                elif response.status not in [200, 404]:
-                    self._errors["base"] = "cannot_connect"
-                    return False
                return True
+            else:
+                check_url = (
+                    f"{endpoint}/v1/models" if self._provider == API_PROVIDER_ANTHROPIC
+                    else f"{endpoint}/models"
+                )
+
+                async with session.get(check_url, headers=headers) as response:
+                    if response.status == 401:
+                        self._errors["base"] = "invalid_auth"
+                        return False
+                    elif response.status not in [200, 404]:
+                        self._errors["base"] = "cannot_connect"
+                        return False
+                    return True

        except Exception as err:
            _LOGGER.error("API validation error: %s", str(err))
@@ -236,6 +388,9 @@ class HATextAIConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):

    def _get_api_headers(self, user_input: Dict[str, Any]) -> Dict[str, str]:
        """Get API headers based on provider."""
+        if CONF_API_KEY not in user_input:
+            return {"Content-Type": "application/json"}
+
        api_key = user_input[CONF_API_KEY]

        if self._provider == API_PROVIDER_ANTHROPIC:
@@ -244,6 +399,11 @@ class HATextAIConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
                "anthropic-version": "2023-06-01",
                "Content-Type": "application/json"
            }
+        elif self._provider == API_PROVIDER_GEMINI:
+            return {
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json"
+            }
        return {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
@@ -256,7 +416,11 @@ class HATextAIConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):

        unique_id = f"{DOMAIN}_{normalized_name}_{self._provider}".lower()

-        default_model = DEFAULT_DEEPSEEK_MODEL if self._provider == API_PROVIDER_DEEPSEEK else DEFAULT_MODEL
+        default_model = (
+            DEFAULT_DEEPSEEK_MODEL if self._provider == API_PROVIDER_DEEPSEEK else
+            DEFAULT_GEMINI_MODEL if self._provider == API_PROVIDER_GEMINI else
+            DEFAULT_MODEL
+        )

        entry_data = {
            CONF_API_PROVIDER: self._provider,
@@ -304,6 +468,13 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
            return self.async_create_entry(title="", data=user_input)

        current_data = {**self.config_entry.data, **self.config_entry.options}
+        provider = current_data.get(CONF_API_PROVIDER)
+
+        default_model = (
+            DEFAULT_DEEPSEEK_MODEL if provider == API_PROVIDER_DEEPSEEK else
+            DEFAULT_GEMINI_MODEL if provider == API_PROVIDER_GEMINI else
+            DEFAULT_MODEL
+        )

        return self.async_show_form(
            step_id="init",
@@ -12,6 +12,8 @@ from typing import Final
 import voluptuous as vol
 from homeassistant.const import Platform, CONF_API_KEY, CONF_NAME
 from homeassistant.helpers import config_validation as cv
+import logging
+_LOGGER = logging.getLogger(__name__)

 # Domain and platforms
 DOMAIN: Final = "ha_text_ai"
@@ -22,11 +24,13 @@ CONF_API_PROVIDER: Final = "api_provider"
 API_PROVIDER_OPENAI: Final = "openai"
 API_PROVIDER_ANTHROPIC: Final = "anthropic"
 API_PROVIDER_DEEPSEEK: Final = "deepseek"
+API_PROVIDER_GEMINI: Final = "gemini"

 API_PROVIDERS: Final = [
    API_PROVIDER_OPENAI,
    API_PROVIDER_ANTHROPIC,
-    API_PROVIDER_DEEPSEEK
+    API_PROVIDER_DEEPSEEK,
+    API_PROVIDER_GEMINI
 ]

 # Read version from manifest.json
@@ -49,6 +53,7 @@ except Exception as err:
 DEFAULT_OPENAI_ENDPOINT: Final = "https://api.openai.com/v1"
 DEFAULT_ANTHROPIC_ENDPOINT: Final = "https://api.anthropic.com"
 DEFAULT_DEEPSEEK_ENDPOINT: Final = "https://api.deepseek.com"
+DEFAULT_GEMINI_ENDPOINT: Final = "https://generativelanguage.googleapis.com/v1beta"

 # Configuration constants
 CONF_MODEL: Final = "model"
@@ -69,6 +74,7 @@ ICONS_SUBDOMAIN = "icons"
 # Default values
 DEFAULT_MODEL: Final = "gpt-4o-mini"
 DEFAULT_DEEPSEEK_MODEL: Final = "deepseek-chat"
+DEFAULT_GEMINI_MODEL: Final = "gemini-2.0-flash"
 DEFAULT_TEMPERATURE: Final = 0.1
 DEFAULT_MAX_TOKENS: Final = 1000
 DEFAULT_REQUEST_INTERVAL: Final = 1.0
@@ -46,19 +46,6 @@ from .const import (

 _LOGGER = logging.getLogger(__name__)

-def _check_memory_available(self):
-    """Check if enough memory is available."""
-    memory = psutil.virtual_memory()
-
-    # Log the total and available memory
-    _LOGGER.debug("Total memory: %s, Available memory: %s", memory.total, memory.available)
-
-    if memory.available > 1024 * 1024 * 100:  # 100MB
-        _LOGGER.debug("Sufficient memory available: %s bytes", memory.available)
-        return True
-    else:
-        _LOGGER.warning("Insufficient memory available: %s bytes", memory.available)
-        return False

 class AsyncFileHandler:
    """Async context manager for file operations."""
@@ -549,25 +536,57 @@ class HATextAICoordinator(DataUpdateCoordinator):
            return 0

    def _sync_write_history_entry(self, entry: dict) -> None:
-        """Synchronous method to write history entry."""
+        """Synchronous method to write history entry with enhanced error handling."""
        try:
            history = []
            if os.path.exists(self._history_file):
-                with open(self._history_file, 'r') as f:
-                    content = f.read()
-                    if content:
-                        history = json.loads(content)
+                try:
+                    with open(self._history_file, 'r', encoding='utf-8') as f:
+                        content = f.read()
+                        if content.strip():
+                            history = json.loads(content)
+                except (json.JSONDecodeError, UnicodeDecodeError) as e:
+                    _LOGGER.warning(f"Corrupted history file, creating new: {e}")
+                    # Backup corrupted file
+                    backup_path = f"{self._history_file}.corrupted.{dt_util.utcnow().strftime('%Y%m%d_%H%M%S')}"
+                    try:
+                        os.rename(self._history_file, backup_path)
+                        _LOGGER.info(f"Corrupted history backed up to: {backup_path}")
+                    except OSError:
+                        pass
+                except PermissionError as e:
+                    _LOGGER.error(f"Permission denied reading history file: {e}")
+                    raise
+                except OSError as e:
+                    _LOGGER.error(f"OS error reading history file: {e}")
+                    raise

            history.append(entry)

            if len(history) > self.max_history_size:
                history = history[-self.max_history_size:]

-            with open(self._history_file, 'w') as f:
-                json.dump(history, f, indent=2)
+            # Write with atomic operation
+            temp_file = f"{self._history_file}.tmp"
+            try:
+                with open(temp_file, 'w', encoding='utf-8') as f:
+                    json.dump(history, f, indent=2, ensure_ascii=False)
+                os.replace(temp_file, self._history_file)
+            except PermissionError as e:
+                _LOGGER.error(f"Permission denied writing history file: {e}")
+                raise
+            except OSError as e:
+                _LOGGER.error(f"OS error writing history file: {e}")
+                # Clean up temp file if it exists
+                try:
+                    os.remove(temp_file)
+                except OSError:
+                    pass
+                raise

        except Exception as e:
            _LOGGER.error(f"Synchronous history entry writing failed: {e}")
+            raise

    async def _rotate_history(self) -> None:
        """Rotate conversation history with file management."""
@@ -903,23 +922,38 @@ class HATextAICoordinator(DataUpdateCoordinator):
                else:
                    response = await self._process_openai_message(question, **kwargs)

+            # Add timestamp and model information to response
+            timestamp = dt_util.utcnow().isoformat()
+            model_used = kwargs.get("model", self.model)
+            
+            # Enhance response with metadata
+            enhanced_response = {
+                "content": response["content"],
+                "tokens": response.get("tokens", {}),
+                "model": model_used,
+                "timestamp": timestamp,
+                "instance": self.instance_name,
+                "question": question,
+                "success": True
+            }
+
            self.last_response = {
-                "timestamp": dt_util.utcnow().isoformat(),
+                "timestamp": timestamp,
                "question": question,
                "response": response["content"],
-                "model": kwargs.get("model", self.model),
+                "model": model_used,
                "instance": self.instance_name,
                "normalized_name": self.normalized_name,
                "error": None,
            }

-            return response
+            return enhanced_response

        except asyncio.TimeoutError:
            raise HomeAssistantError("Request timed out")

        except Exception as err:
-            self._handle_error(err)
+            await self._handle_error(err)
            raise

    async def _process_anthropic_message(self, question: str, **kwargs) -> dict:
@@ -1051,15 +1085,84 @@ class HATextAICoordinator(DataUpdateCoordinator):
            _LOGGER.error(f"Error clearing history: {e}")
            _LOGGER.debug(traceback.format_exc())

-    async def async_get_history(self) -> List[Dict[str, str]]:
-        """Get conversation history."""
-        return self._conversation_history
+    async def async_get_history(
+        self,
+        limit: Optional[int] = None,
+        filter_model: Optional[str] = None,
+        start_date: Optional[str] = None,
+        include_metadata: bool = False,
+        sort_order: str = "newest"
+    ) -> List[Dict[str, Any]]:
+        """Get conversation history with optional filtering and sorting."""
+        try:
+            history = self._conversation_history.copy()
+            
+            # Filter by model if specified
+            if filter_model:
+                history = [entry for entry in history if entry.get("model") == filter_model]
+            
+            # Filter by start date if specified
+            if start_date:
+                try:
+                    from datetime import datetime
+                    start_dt = datetime.fromisoformat(start_date.replace('Z', '+00:00'))
+                    history = [
+                        entry for entry in history 
+                        if datetime.fromisoformat(entry["timestamp"].replace('Z', '+00:00')) >= start_dt
+                    ]
+                except (ValueError, KeyError) as e:
+                    _LOGGER.warning(f"Invalid start_date format: {start_date}. Error: {e}")
+            
+            # Sort history
+            if sort_order == "oldest":
+                history.sort(key=lambda x: x.get("timestamp", ""))
+            else:  # newest (default)
+                history.sort(key=lambda x: x.get("timestamp", ""), reverse=True)
+            
+            # Apply limit
+            if limit and limit > 0:
+                history = history[:limit]
+            
+            # Add metadata if requested
+            if include_metadata:
+                for entry in history:
+                    entry["metadata"] = {
+                        "entry_size": len(str(entry)),
+                        "question_length": len(entry.get("question", "")),
+                        "response_length": len(entry.get("response", "")),
+                        "model_used": entry.get("model", self.model),
+                        "instance": self.instance_name
+                    }
+            
+            return history
+            
+        except Exception as e:
+            _LOGGER.error(f"Error getting history: {e}")
+            return []

    async def async_set_system_prompt(self, prompt: str) -> None:
        """Set system prompt."""
        self._system_prompt = prompt
        await self.async_update_ha_state()

+    def _check_memory_available(self) -> bool:
+        """Check if enough memory is available."""
+        try:
+            memory = psutil.virtual_memory()
+            
+            # Log the total and available memory
+            _LOGGER.debug("Total memory: %s, Available memory: %s", memory.total, memory.available)
+            
+            if memory.available > 1024 * 1024 * 100:  # 100MB
+                _LOGGER.debug("Sufficient memory available: %s bytes", memory.available)
+                return True
+            else:
+                _LOGGER.warning("Insufficient memory available: %s bytes", memory.available)
+                return False
+        except Exception as e:
+            _LOGGER.error("Error checking memory availability: %s", e)
+            return True  # Assume memory is available if check fails
+
    async def async_shutdown(self) -> None:
        """Shutdown coordinator."""
        _LOGGER.debug(f"Shutting down coordinator for {self.instance_name}")
@@ -13,16 +13,17 @@
  "loggers": ["custom_components.ha_text_ai"],
  "mqtt": [],
  "quality_scale": "silver",
-    "requirements": [
-      "openai>=1.12.0",
-      "anthropic>=0.8.0",
-      "aiohttp>=3.8.0",
-      "async-timeout>=4.0.0",
-      "certifi>=2024.2.2"
-    ],
+  "requirements": [
+    "openai>=1.12.0",
+    "anthropic>=0.8.0",
+    "google-genai>=1.16.0",
+    "aiohttp>=3.8.0",
+    "async-timeout>=4.0.0",
+    "certifi>=2024.2.2"
+  ],
  "single_config_entry": false,
  "ssdp": [],
  "usb": [],
-  "version": "2.1.1",
+  "version": "2.1.9",
  "zeroconf": []
 }
@@ -9,6 +9,7 @@ Sensor platform for HA Text AI.
 import logging
 import math
 from typing import Any, Dict
+from datetime import datetime, timedelta

 from homeassistant.components.sensor import (
    SensorEntity,
@@ -3,6 +3,7 @@ ask_question:
  description: >-
    Send a question to the AI model and receive a detailed response.
    The response will be stored in the conversation history and can be retrieved later.
+    This service now returns response data directly, eliminating the need to read from sensors.
  fields:
    instance:
      name: Instance
@@ -63,13 +64,13 @@ ask_question:

    max_tokens:
      name: Max Tokens
-      description: Maximum length of the response (1-4096 tokens)
+      description: Maximum length of the response (tokens)
      required: false
      default: 1000
      selector:
        number:
          min: 1
-          max: 4096
+          max: 100000
          step: 1
          mode: box

@@ -88,16 +88,17 @@
  "selector": {
    "api_provider": {
      "options": {
-        "openai": "OpenAI (kompatibel)",
-        "anthropic": "Anthropic (kompatibel)",
-        "deepseek": "DeepSeek"
+        "openai": "OpenAI (compatible)",
+        "anthropic": "Anthropic (compatible)",
+        "deepseek": "DeepSeek",
+        "gemini": "Google Gemini"
      }
    }
  },
  "services": {
    "ask_question": {
      "name": "Frage stellen (HA Text AI)",
-      "description": "Stellen Sie eine Frage an das AI-Modell und erhalten Sie eine detaillierte Antwort. Die Antwort wird im Gesprächsverlauf gespeichert und kann später abgerufen werden.",
+      "description": "Stellen Sie eine Frage an das AI-Modell und erhalten Sie eine detaillierte Antwort. Dieser Service gibt jetzt Antwortdaten direkt zurück, wodurch separate Textsensoren und die 255-Zeichen-Begrenzung überflüssig werden. Die Antwort wird auch im Gesprächsverlauf gespeichert.",
      "fields": {
        "instance": {
          "name": "Instanz",
@@ -86,18 +86,19 @@
    }
  },
  "selector": {
-  "api_provider": {
-    "options": {
-      "openai": "OpenAI (compatible)",
-      "anthropic": "Anthropic (compatible)",
-      "deepseek": "DeepSeek"
+    "api_provider": {
+      "options": {
+        "openai": "OpenAI (compatible)",
+        "anthropic": "Anthropic (compatible)",
+        "deepseek": "DeepSeek",
+        "gemini": "Google Gemini"
+      }
    }
-  }
-},
+  },
  "services": {
    "ask_question": {
      "name": "Ask Question (HA Text AI)",
-      "description": "Send a question to the AI model and receive a detailed response. The response will be stored in the conversation history and can be retrieved later.",
+      "description": "Send a question to the AI model and receive a detailed response. This service now returns response data directly, eliminating the need for separate text sensors and the 255-character limitation. The response will also be stored in the conversation history.",
      "fields": {
        "instance": {
          "name": "Instance",
@@ -90,14 +90,15 @@
      "options": {
        "openai": "OpenAI (compatible)",
        "anthropic": "Anthropic (compatible)",
-        "deepseek": "DeepSeek"
+        "deepseek": "DeepSeek",
+        "gemini": "Google Gemini"
      }
    }
  },
  "services": {
    "ask_question": {
      "name": "Hacer Pregunta (HA Text AI)",
-      "description": "Envía una pregunta al modelo de IA y recibe una respuesta detallada. La respuesta se almacenará en el historial de conversación y se podrá recuperar más tarde.",
+      "description": "Envía una pregunta al modelo de IA y recibe una respuesta detallada. Este servicio ahora devuelve datos de respuesta directamente, eliminando la necesidad de sensores de texto separados y la limitación de 255 caracteres. La respuesta también se almacenará en el historial de conversación.",
      "fields": {
        "instance": {
          "name": "Instancia",
@@ -1,15 +1,6 @@
 {
  "config": {
    "step": {
-      "provider": {
-        "title": "एआई प्रदाता चुनें",
-        "description": "इस उदाहरण के लिए किस एआई सेवा प्रदाता का उपयोग करना है, चुनें।",
-        "data": {
-          "api_provider": "एपीआई प्रदाता",
-          "context_messages": "रखने के लिए संदर्भ संदेशों की संख्या (1-20)",
-          "max_history_size": "अधिकतम बातचीत इतिहास आकार (1-100)"
-        }
-      },
      "provider": {
        "title": "प्रदाता सेटिंग्स",
        "description": "आपके द्वारा चुने गए एआई प्रदाता के लिए कनेक्शन विवरण प्रदान करें।",
@@ -90,14 +81,15 @@
      "options": {
        "openai": "OpenAI (अनुकूलित)",
        "anthropic": "Anthropic (अनुकूलित)",
-        "deepseek": "DeepSeek"
+        "deepseek": "DeepSeek",
+        "gemini": "Google Gemini"
      }
    }
  },
  "services": {
    "ask_question": {
      "name": "प्रश्न पूछें (HA Text AI)",
-      "description": "एआई मॉडल को एक प्रश्न भेजें और विस्तृत प्रतिक्रिया प्राप्त करें। प्रतिक्रिया बातचीत के इतिहास में संग्रहीत की जाएगी और बाद में पुनर्प्राप्त की जा सकती है।",
+      "description": "AI मॉडल को प्रश्न भेजें और विस्तृत उत्तर प्राप्त करें। यह सेवा अब प्रत्यक्ष रूप से प्रतिक्रिया डेटा वापस करती है, अलग टेक्स्ट सेंसर की आवश्यकता और 255 वर्ण की सीमा को समाप्त करती है। प्रतिक्रिया को बातचीत के इतिहास में भी संग्रहीत किया जाएगा।",
      "fields": {
        "instance": {
          "name": "उदाहरण",
@@ -294,4 +286,4 @@
      }
    }
  }
-}
+}
@@ -90,14 +90,15 @@
      "options": {
        "openai": "OpenAI (compatibile)",
        "anthropic": "Anthropic (compatibile)",
-        "deepseek": "DeepSeek"
+        "deepseek": "DeepSeek",
+        "gemini": "Google Gemini"
      }
    }
  },
  "services": {
    "ask_question": {
      "name": "Fai una domanda (HA Text AI)",
-      "description": "Invia una domanda al modello AI e ricevi una risposta dettagliata. La risposta sarà memorizzata nella cronologia delle conversazioni e potrà essere recuperata in seguito.",
+      "description": "Invia una domanda al modello AI e ricevi una risposta dettagliata. Questo servizio ora restituisce i dati di risposta direttamente, eliminando la necessità di sensori di testo separati e la limitazione di 255 caratteri. La risposta sarà anche memorizzata nella cronologia delle conversazioni.",
      "fields": {
        "instance": {
          "name": "Istanze",
@@ -90,14 +90,15 @@
      "options": {
        "openai": "OpenAI (совместимый)",
        "anthropic": "Anthropic (совместимый)",
-        "deepseek": "DeepSeek"
+        "deepseek": "DeepSeek",
+        "gemini": "Google Gemini"
      }
    }
  },
  "services": {
    "ask_question": {
      "name": "Задать вопрос (HA Text AI)",
-      "description": "Отправить вопрос модели ИИ и получить подробный ответ. Ответ будет сохранен в истории разговора и может быть получен позже.",
+      "description": "Отправить вопрос модели ИИ и получить подробный ответ. Сервис теперь возвращает данные ответа напрямую, устраняя необходимость в отдельных текстовых сенсорах и ограничение в 255 символов. Ответ также будет сохранен в истории разговора.",
      "fields": {
        "instance": {
          "name": "Экземпляр",
@@ -1,15 +1,6 @@
 {
  "config": {
    "step": {
-      "provider": {
-        "title": "Изаберите AI провајдера",
-        "description": "Изаберите који AI сервис провајдер да користите за ову инстанцу.",
-        "data": {
-          "api_provider": "API провајдер",
-          "context_messages": "Број контекстуалних порука које треба задржати (1-20)",
-          "max_history_size": "Максимална величина историје разговора (1-100)"
-        }
-      },
      "provider": {
        "title": "Подешавања провајдера",
        "description": "Обезбедите детаље о вези за изабраног AI провајдера.",
@@ -90,14 +81,15 @@
      "options": {
        "openai": "OpenAI (компатибилан)",
        "anthropic": "Anthropic (компатибилан)",
-        "deepseek": "DeepSeek"
+        "deepseek": "DeepSeek",
+        "gemini": "Google Gemini"
      }
    }
  },
  "services": {
    "ask_question": {
      "name": "Поставите питање (HA Text AI)",
-      "description": "Пошаљите питање AI моделу и примите детаљан одговор. Одговор ће бити сачуван у историји разговора и може се касније повратити.",
+      "description": "Пошаљите питање AI моделу и добијте детаљан одговор. Овај сервис сада враћа податке одговора директно, елиминишући потребу за засебним текстуалним сензорима и ограничење од 255 карактера. Одговор ће такође бити сачуван у историји разговора.",
      "fields": {
        "instance": {
          "name": "Инстанца",
@@ -294,4 +286,4 @@
      }
    }
  }
-}
+}
@@ -1,15 +1,6 @@
 {
  "config": {
    "step": {
-      "provider": {
-        "title": "选择AI提供者",
-        "description": "选择要用于此实例的AI服务提供者。",
-        "data": {
-          "api_provider": "API提供者",
-          "context_messages": "保留的上下文消息数量（1-20）",
-          "max_history_size": "最大对话历史大小（1-100）"
-        }
-      },
      "provider": {
        "title": "提供者设置",
        "description": "提供所选AI提供者的连接详细信息。",
@@ -90,14 +81,15 @@
      "options": {
        "openai": "OpenAI（兼容）",
        "anthropic": "Anthropic（兼容）",
-        "deepseek": "DeepSeek "
+        "deepseek": "DeepSeek",
+        "gemini": "Google Gemini"
      }
    }
  },
  "services": {
    "ask_question": {
      "name": "提问 (HA Text AI)",
-      "description": "向AI模型发送问题并接收详细响应。响应将存储在对话历史中，可以稍后检索。",
+      "description": "向AI模型发送问题并获得详细回答。此服务现在直接返回响应数据，消除了对单独文本传感器的需要和255字符限制。响应也将存储在对话历史中。",
      "fields": {
        "instance": {
          "name": "实例",
@@ -294,4 +286,4 @@
      }
    }
  }
-}
+}
@@ -0,0 +1,8 @@
+{
+	"folders": [
+		{
+			"path": "."
+		}
+	],
+	"settings": {}
+}
@@ -1,5 +1,5 @@
 {
-  "name": "HA text AI",
+  "name": "HA Text AI",
  "render_readme": true,
-  "homeassistant": "2024.11.0"
+  "homeassistant": "2024.12.0"
 }
Author	SHA1	Message	Date
SMKRV	e91c3701c5	Fix: Resolve get_history service parameter handling issue - Fixed async_get_history method to accept limit parameter and other filtering options - Updated service schema to support all parameters from services.yaml - Added support for start_date, include_metadata, and sort_order parameters - Version bump to 2.1.9	2025-09-02 23:27:34 +03:00
smkrv	7f62101b3e	Update HACS minimum HA version to align with README requirement (2024.12.0)	2025-09-02 23:15:01 +03:00
smkrvandGitHub	3729c3736f	Update hassfest.yaml	2025-09-02 09:36:46 +03:00
smkrvandGitHub	f5ce5e459a	Update hassfest.yaml fix: https://github.com/smkrv/ha-text-ai/security/code-scanning/2	2025-09-02 09:24:35 +03:00
smkrv GitHubCopilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com>	4064486b1e	Potential fix for code scanning alert no. 1: Workflow does not contain permissions Co-authored-by: Copilot Autofix powered by AI <62310815+github-advanced-security[bot]@users.noreply.github.com>	2025-09-02 09:18:15 +03:00
SMKRV	185778dbd0	docs: Update AI models to latest versions - Update OpenAI models to GPT-5 and GPT-5 mini - Update Anthropic Claude models to 4.1, 4.0 series - Update DeepSeek models to V3.1 and R1 - Update Google Gemini models to 2.5 and 2.0 series - Modernize model descriptions and capabilities	2025-09-02 02:19:37 +03:00
SMKRV	83a255dee0	docs: Update README.md - actualize documentation - Simplify HACS installation instructions - Update recommended models section (remove year from title) - Update Claude model names to current format (claude-3.5-sonnet, claude-3.5-haiku) - Add missing parameters to get_history service documentation - Remove non-configurable history_file_size parameter from table - Add missing context_messages parameter to configuration table - Update all model references in examples to use current naming	2025-09-02 02:11:34 +03:00
SMKRV	6b66dd6a4d	docs: Update README with latest configuration defaults and Gemini models - Update default model from gpt-4o to gpt-4o-mini - Update default temperature from 0.7 to 0.1 - Update default max_history_size from 100 to 50 - Add gemini-2.0-flash as latest recommended Gemini model - Fix logo image link to use main branch instead of specific commit - Update configuration parameters table with current defaults	2025-09-02 02:06:58 +03:00
SMKRV	bd82f23120	docs: Update HACS badge from Custom to Default	2025-09-02 01:56:24 +03:00
SMKRV	eee9754033	fix: Fix JSON syntax errors in translation files - Fixed missing closing brace in es.json selector.api_provider.options - Fixed missing closing brace in de.json selector.api_provider.options - All other translation files (hi.json, it.json, sr.json, zh.json) have correct syntax - Ensures proper JSON validation and prevents parsing errors	2025-09-02 01:26:49 +03:00
SMKRV	517b1f11ae	fix: Remove invalid response schema from services.yaml Home Assistant's hassfest validation does not support 'response' section in services.yaml. The response_variable functionality still works through supports_response=True flag in service registration. Fixes hassfest validation error: extra keys not allowed @ data['ask_question']['response']	2025-09-02 01:22:20 +03:00
SMKRV	ed8f19bfa9	fix: Add support for response_variable in ask_question service - Added response schema definition in services.yaml for ask_question service - Set supports_response=True flag when registering the service - Fixed JSON syntax error in English translation file - Added comprehensive documentation with examples for response_variable usage - Users can now capture AI responses directly in variables without sensor delays Resolves issue where scripts failed with 'Script does not support response_variable' error	2025-09-02 01:19:44 +03:00
SMKRV	7e3daf611b	fix: Remove target requirements from services to fix mandatory device/area/entity selection issue - Removed target blocks from all services in services.yaml - Services now work as global services without requiring device/area/entity selection - Users can call services directly with only required parameters - Fixes issue #2 where services incorrectly required target selection after v2.1.8 update	2025-09-01 23:40:26 +03:00
SMKRV	37919be70f	fix: Resolve hassfest validation errors in services.yaml - Remove invalid response schema from ask_question service - Add required target configuration for all services - Ensure compliance with Home Assistant service schema requirements	2025-09-01 17:20:40 +03:00
SMKRV	e427254584	feat: Implement response variables support and comprehensive production audit (v2.1.8) 🚀 Major Features: - Add response variables support to ask_question service - Eliminate 255-character limitation for AI responses - Enable direct data access in automations without sensors - Prevent race conditions in parallel automations 🔧 Production Code Audit & Fixes: - Enhanced resource management with context managers in api_client.py - Fixed critical race conditions with asyncio.Semaphore implementation - Improved file operations with atomic writes and corruption handling - Enhanced error handling and logging security (removed sensitive data) - Fixed _check_memory_available method placement in coordinator.py 🌐 Translation Updates (8 languages): - Updated all translation files with response variables information - Enhanced service descriptions in: en, ru, de, es, it, hi, sr, zh - Added information about direct response capability - Maintained consistency across all language files 📚 Documentation Enhancements: - Added comprehensive Response Variables section to README - Created advanced automation examples with response_variable usage - Added migration guide from sensors to response variables - Enhanced service documentation with response data structure - Added practical examples for multi-step AI workflows 🔄 Service Improvements: - Enhanced ask_question service to return structured response data - Added comprehensive response schema in services.yaml - Improved error handling with success/failure indicators - Added metadata support (tokens, model, timestamp) �� Version & Manifest: - Bumped version to 2.1.8 - Maintained compatibility with existing integrations - Updated service documentation This release addresses GitHub issue #2 and significantly improves the integration's production readiness while adding powerful new response variable functionality.	2025-09-01 17:14:23 +03:00
SMKRV	76c5629fa0	refactor(google-gemini): rewrite integration using google-genai 1.16.0 Completely rewrote the Google Gemini integration logic based on google-genai 1.16.0 to fix issue #6. Key changes: - Updated to the latest google-genai library - Made API endpoint abstract while retaining option for custom endpoint configuration - Refactored logic and classes exclusively within Google Gemini implementation - All changes are limited to Google Gemini integration refactoring with no impact on other functionality.	2025-05-21 01:27:47 +03:00
SMKRV	7958bd010b	refactor(google-gemini): rewrite integration using google-genai 1.16.0 Completely rewrote the Google Gemini integration logic based on google-genai 1.16.0 to fix issue #6. Key changes: - Updated to the latest google-genai library - Made API endpoint abstract while retaining option for custom endpoint configuration - Refactored logic and classes exclusively within Google Gemini implementation - All changes are limited to Google Gemini integration refactoring with no impact on other functionality.	2025-05-21 01:26:42 +03:00
SMKRV	8cd876195a	Bump to version 2.1.6	2025-05-20 01:50:06 +03:00
SMKRV	376753e001	fix: correct field naming in Gemini API requests from camelCase to snake_case and improve message handling	2025-05-20 01:42:38 +03:00
SMKRV	b6e73e847d	fix(api_client): correct Google Gemini API integration - Change JSON field names from camelCase to snake_case as required by Gemini API (generation_config, max_output_tokens, system_instruction) - Improve message handling to ensure proper role alternation (user/model) - Add safety checks for empty contents and ensure first message is always from user - Implement robust error handling and response parsing - Handle edge cases where candidatesTokenCount might be returned as a list Fixes #6	2025-05-20 01:16:41 +03:00
SMKRV	440c734214	Bump release version to v2.1.4	2025-05-19 23:20:27 +03:00
SMKRV	73788373cd	Release v2.1.3	2025-05-19 23:12:55 +03:00
SMKRV	4bfc96019b	fix: DEFAULT_GEMINI_ENDPOINT	2025-05-19 15:53:43 +03:00
SMKRV	2138fc7654	fix: DEFAULT_GEMINI_ENDPOINT	2025-05-19 15:36:58 +03:00
SMKRV	95bd2ebb41	Add support for Google Gemini (thanks to @Azzedde) #5	2025-05-19 15:10:19 +03:00
smkrvandGitHub	cad0fd7031	Merge pull request #5 from Azzedde/main Add Gemini API provider support to HA Text AI integration by @Azzedde	2025-05-19 14:44:06 +03:00
Azzedde	c003b258f6	Add Gemini API provider support to HA Text AI integration	2025-05-18 13:23:55 +02:00
SMKRV	65a10c77f4	~	2025-01-30 01:15:13 +03:00
SMKRV	e1463828c9	~	2025-01-30 01:14:24 +03:00
SMKRV	5ebb9c9c66	fix: max_tokens value	2025-01-29 18:04:13 +03:00
SMKRV	f17c631a79	fix: max_tokens value	2025-01-29 18:02:42 +03:00
SMKRV	0e06794384	refactor(docs): shields & community links updated	2025-01-29 03:05:47 +03:00
SMKRV	d8a924909b	refactor(docs): shields & community links updated	2025-01-29 03:05:11 +03:00
SMKRV	29f1659a02	refactor(docs): shields & community links updated	2025-01-29 03:04:39 +03:00
SMKRV	5b7905de80	refactor(docs): shields & community links updated	2025-01-29 03:03:48 +03:00
SMKRV	cf9ac6dcea	refactor(docs): shields & community links updated	2025-01-29 01:08:45 +03:00
SMKRV	568eb3e16c	refactor(docs): shields updated	2025-01-29 00:58:27 +03:00
SMKRV	53fb150389	refactor(docs): shields updated	2025-01-29 00:58:09 +03:00
SMKRV	acbb53d2af	refactor(docs): shields updated	2025-01-29 00:57:27 +03:00
SMKRV	e19db29441	refactor(docs): DeepSeek Integration	2025-01-28 16:25:59 +03:00