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
fix: Remove invalid response schema from services.yaml
2026-07-22 15:14:01 +08:00 · 2025-09-02 01:26:49 +03:00 · 2025-09-02 01:22:20 +03:00 · 2025-09-02 01:19:44 +03:00 · 2025-09-01 23:40:26 +03:00 · 2025-09-01 17:20:40 +03:00
35 changed files with 1948 additions and 680 deletions
@@ -1,40 +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
@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+  and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+  overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+  advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+  address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+issue tracker.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior,  harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.
@@ -2,124 +2,167 @@

 <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) ![/README.md](https://img.shields.io/badge/language-English-green?style=flat-square) ![/README_RU.md](https://img.shields.io/badge/language-Russian-green?style=flat-square) ![](https://img.shields.io/badge/language-Deutch-green?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-Custom-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/524849f6a945ec62c2cf6a6b7ecd9a28b37bf0fa/misc/icons/logo.jpg" alt="HA Text AI" height="160"/>
+
+  <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;"/>

 ### 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]
-> 🚧 BETA VERSION  
-> Expect: potential bugs, frequent changes, incomplete features.  
-> 🤝 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](misc/screenshots/screenshot.jpg)
+> [Screenshots](assets/images/screenshots/screenshot.jpg)

 ## 🌟 Features

- 🧠 **Multi-Provider AI Integration**:
-  - Support for OpenAI GPT models
-  - Anthropic Claude integration
-  - Custom API endpoints
-  - Flexible model selection
+- 🧠 **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
+- 🎯 **Advanced Customization**: Per-request model and parameter selection
+- 🔒 **Enhanced Security**: Secure API key management and usage monitoring
+- 🎨 **Improved User Experience**: Intuitive configuration and rich interfaces
+- 🔄 **Automation Integration**: Event-driven responses and template compatibility

- 💬 **Advanced Language Processing**:
-  - Context-aware responses
-  - Multi-turn conversations
-  - Custom system instructions
-  - Natural conversation flow
+<details>
+<summary>📦 Detailed Feature Breakdown</summary>

- 📝 **Enhanced Memory Management**:
-  - File-based conversation history storage
-  - Automatic history rotation
-  - Configurable history size limits
-  - Secure storage in Home Assistant
+### 🧠 **Multi-Provider AI Integration**
+- Support for OpenAI GPT models
+- Anthropic Claude integration
+- DeepSeek integration
+- Custom API endpoints
+- Flexible model selection

- ⚡ **Performance Optimization**:
-  - Efficient token usage
-  - Smart rate limiting
-  - Response caching
-  - Request interval control
+### 💬 **Advanced Language Processing**
+- Context-aware responses
+- Multi-turn conversations
+- Custom system instructions
+- Natural conversation flow

- 🎯 **Advanced Customization**:
-  - Per-request model selection
-  - Adjustable parameters
-  - Custom system prompts
-  - Temperature control
+### 📝 **Enhanced Memory Management**
+- File-based conversation history storage
+- Automatic history rotation
+- Configurable history size limits
+- Secure storage in Home Assistant

- 🔒 **Enhanced Security**:
-  - Secure API key storage
-  - Rate limiting protection
-  - Error handling
-  - Usage monitoring
+### ⚡ **Performance Optimization**
+- Efficient token usage
+- Smart rate limiting
+- Response caching
+- Request interval control

- 🎨 **Improved User Experience**:
-  - Intuitive configuration UI
-  - Detailed sensor attributes
-  - Rich service interface
-  - Model selection UI
+### 🎯 **Advanced Customization**
+- Per-request model selection
+- Adjustable parameters
+- Custom system prompts
+- Temperature control

- 🔄 **Automation Integration**:
-  - Event-driven responses
-  - Conditional logic support
-  - Template compatibility
-  - Model-specific automation
+### 🔒 **Enhanced Security**
+- Secure API key storage
+- Rate limiting protection
+- Error handling
+- Usage monitoring
+
+### 🎨 **Improved User Experience**
+- Intuitive configuration UI
+- Detailed sensor attributes
+- Rich service interface
+- Model selection UI
+
+### 🔄 **Automation Integration**
+- Event-driven responses
+- Conditional logic support
+- Template compatibility
+- Model-specific automation
+
+</details>
+
+#### 🌐 Translations
+
+| Code | Language | Status |
+|------|----------|--------|
+| 🇩🇪 de | Deutsch | Full |
+| 🇬🇧 en | English | Primary |
+| 🇪🇸 es | Español | Full |
+| 🇮🇳 hi | हिन्दी | Full |
+| 🇮🇹 it | Italiano | Full |
+| 🇷🇺 ru | Русский | Full |
+| 🇷🇸 sr | Српски | Full |
+| 🇨🇳 zh | 中文 | Full |

 ## 📋 Prerequisites

- Home Assistant 2024.11 or later
+- Home Assistant 2024.2.2 or later
 - 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))
  - 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

-### Configuration Options
- API Provider (OpenAI/Anthropic)
- API Key (provider-specific)
- Model Selection (flexible, provider-specific models)
- Temperature (Creativity control, 0.0-2.0)
- Max Tokens (Response length limit)
- Request Interval (API call throttling)
- Custom API Endpoint (optional)
+## Configuration Options

-#### ⓘ Potentially Compatible Providers  
-The integration is designed to be flexible and may work with other providers offering OpenAI-compatible APIs:  
- Groq  
- Together AI  
- Perplexity AI  
- Mistral AI  
- Google AI  
- Local AI servers (like Ollama)  
- Custom OpenAI-compatible endpoints  
+### 🔧 **Core Configuration Settings**
+- 🌐 **API Provider**: OpenAI/Anthropic/DeepSeek
+- 🔑 **API Key**: Provider-specific authentication
+- 🤖 **Model Selection**: Flexible, provider-specific models
+- 🌡️ **Temperature**: Creativity control (0.0-2.0)
+- 📏 **Max Tokens**: Response length limit (passed directly to the LLM API to control the maximum length of the response)
+- ⏱️ **Request Interval**: API call throttling
+- 💾 **History Size**: Number of messages to retain
+- 🌍 **Custom API Endpoint**: Optional advanced configuration

-#### Additional Notes  
- Not all providers guarantee full compatibility  
- Performance may vary between providers  
- Check individual provider's documentation  
+<details>
+<summary>🌐 Potentially Compatible Providers</summary>
+
+#### Flexible Provider Ecosystem
+The integration is designed to be flexible and may work with other providers offering OpenAI-compatible APIs:
+- Groq
+- Together AI
+- Perplexity AI
+- Mistral AI
+- Google AI
+- Local AI servers (like Ollama)
+- Custom OpenAI-compatible endpoints
+
+#### 🚨 Compatibility Notes
+- Not all providers guarantee full compatibility
+- Performance may vary between providers
+- Check individual provider's documentation
 - Ensure your API key has sufficient credits/quota

-#### Provider Compatibility Requirements  
-To be compatible, a provider should support:  
- OpenAI-like REST API structure  
- JSON request/response format  
- Standard authentication method  
+#### 🔍 Provider Compatibility Requirements
+To be compatible, a provider should support:
+- OpenAI-like REST API structure
+- JSON request/response format
+- Standard authentication method
 - Similar model parameter handling

+</details>
+
 ## ⚡ 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"
@@ -144,7 +187,8 @@ To be compatible, a provider should support:
 3. Search for "HA Text AI"
 4. Follow the configuration steps

-### Via YAML
+<details>
+<summary>📦 Via YAML (Advanced)</summary>

 ### Platform Configuration (Global Settings)

@@ -202,8 +246,20 @@ sensor:
 | `temperature` | Float | ❌ | Platform setting | Override global temperature |
 | `max_tokens` | Integer | ❌ | Platform setting | 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
@@ -214,12 +270,30 @@ data:
  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-sonnet"
+instance: "sensor.ha_text_ai_gpt"
+question: "What's the optimal temperature for sleeping?"
+timestamp: "2025-01-09T16:57:00.000Z"
+success: true
+# error: "Error message" (only present if success: false)
 ```

 ### set_system_prompt
 ```yaml
 service: ha_text_ai.set_system_prompt
 data:
+  instance: sensor.ha_text_ai_gpt
  prompt: |
    You are a home automation expert focused on:
    1. Energy efficiency
@@ -231,6 +305,8 @@ data:
 ### clear_history
 ```yaml
 service: ha_text_ai.clear_history
+data:
+  instance: sensor.ha_text_ai_gpt
 ```

 ### get_history
@@ -239,6 +315,150 @@ service: ha_text_ai.get_history
 data:
  limit: 5  # optional
  filter_model: "gpt-4o"  # optional
+  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
@@ -258,7 +478,7 @@ sensor.ha_text_ai_YOUR_UNIQUE_SUFFIX
 # Examples:
 sensor.ha_text_ai_gpt      # GPT-based sensor
 sensor.ha_text_ai_claude   # Claude-based sensor
-sensor.ha_text_ai_gpt   # Custom suffix
+sensor.ha_text_ai_abc      # Custom suffix
 ```

 #### Response Retrieval
@@ -275,6 +495,7 @@ automation:
      - service: ha_text_ai.ask_question
        data:
          question: "Home automation advice"
+          instance: sensor.ha_text_ai_gpt
      - service: notify.mobile
        data:
          message: >
@@ -291,6 +512,16 @@ automation:

 ### 🔍 HA Text AI Sensor Attributes

+- 🤖 **Model and Provider Information**: Tracking current AI model and service provider
+- 🚦 **System Status**: Real-time API and processing readiness
+- 📊 **Performance Metrics**: Request success rates and response times
+- 💬 **Conversation Tracking**: Token usage and interaction history are estimated using a heuristic method based on word count and specific word characteristics, which may differ from actual token usage.
+- 🕒 **Last Interaction Details**: Recent query and response tracking
+- ❤️ **System Health**: Error monitoring and service uptime
+
+<details>
+<summary>📦 Detailed Sensor Attributes</summary>
+
 #### Model and Provider Information
 ```yaml
 # Name of the AI model currently in use (e.g., latest version of GPT)  
@@ -350,9 +581,8 @@ automation:
 # Number of entries in current history file
 {{ state_attr('sensor.ha_text_ai_gpt', 'History size') }}          # 0  

-# Last few conversation entries (limited to 3 for performance)
+# Last few conversation entries (limited to 1 for performance)
 {{ state_attr('sensor.ha_text_ai_gpt', 'conversation_history') }}  # [...]
-
 ```

 #### Last Interaction Details
@@ -381,7 +611,7 @@ automation:

 ### History Storage
 Conversation history stored in `.storage/ha_text_ai_history/` directory:
- Each instance has its own history file
+- Each instance has its own history file (JSON)
 - Files are automatically rotated when size limit is reached
 - Archived history files are timestamped
 - Default maximum file size: 1MB
@@ -391,6 +621,7 @@ Conversation history stored in `.storage/ha_text_ai_history/` directory:
 - Use these attributes for monitoring and automation
 - Some values might be 0 or empty initially

+</details>

 ## 📘 FAQ

@@ -427,7 +658,6 @@ A: Yes, archived history files are stored with timestamps and can be accessed ma
 **Q: How much history is kept?**  
 A: By default, up to 100 conversations are stored, but this can be configured. Files are automatically rotated when they reach 1MB.

-
 ## 🤝 Contributing

 Contributions welcome! Please read our [Contributing Guide](CONTRIBUTING.md).
@@ -474,9 +704,11 @@ 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 ❤️ and Claude 3.5 Sonnet for the Home Assistant Community
+Made with ❤️ for the Home Assistant Community,  
+utilizing Claude 3.5 Sonnet, Gemini Pro 1.5, and Qwen 2.5 Coder 32B Instruct.

 [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.
@@ -11,8 +11,9 @@ from __future__ import annotations
 import logging
 import os
 import shutil
+import hashlib
 from datetime import datetime, timedelta
-from typing import Any, Dict
+from typing import Any, Dict, TypeVar

 import voluptuous as vol
 from async_timeout import timeout
@@ -38,11 +39,17 @@ from .const import (
    CONF_CONTEXT_MESSAGES,
    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,
@@ -52,11 +59,13 @@ from .const import (
    SERVICE_SET_SYSTEM_PROMPT,
    DEFAULT_MAX_HISTORY,
    CONF_MAX_HISTORY_SIZE,
+    ICONS_SUBDOMAIN,
 )

 _LOGGER = logging.getLogger(__name__)

 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
+ConfigType = TypeVar("ConfigType", bound=Dict[str, Any])

 SERVICE_SCHEMA_ASK_QUESTION = vol.Schema({
    vol.Required("instance"): cv.string,
@@ -90,25 +99,24 @@ def get_coordinator_by_instance(hass: HomeAssistant, instance: str) -> HATextAIC

    raise HomeAssistantError(f"Instance {instance} not found")

-async def async_setup(hass: HomeAssistant, config: Dict[str, Any]) -> bool:
-    """Set up the HA Text AI component."""
+def get_file_hash(file_path: str) -> str:
+    """Calculate SHA256 hash of file."""
+    sha256_hash = hashlib.sha256()
+    with open(file_path, "rb") as f:
+        for byte_block in iter(lambda: f.read(4096), b""):
+            sha256_hash.update(byte_block)
+    return sha256_hash.hexdigest()
+
+async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
+    """Set up the Home Assistant Text AI component."""
+    # Initialize domain data storage
    hass.data.setdefault(DOMAIN, {})

-    try:
-        source = os.path.join(os.path.dirname(__file__), 'icons', 'icon.svg')
-        dest_dir = os.path.join(hass.config.path('www'), 'icons')
-        os.makedirs(dest_dir, exist_ok=True)
-        dest = os.path.join(dest_dir, 'icon.png')
-        if not os.path.exists(dest):
-            shutil.copyfile(source, dest)
-    except Exception as ex:
-        _LOGGER.warning("Failed to copy custom icon: %s", str(ex))
-
-    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"),
@@ -116,9 +124,34 @@ async def async_setup(hass: HomeAssistant, config: Dict[str, Any]) -> 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."""
@@ -150,11 +183,13 @@ async def async_setup(hass: HomeAssistant, config: Dict[str, Any]) -> bool:
            _LOGGER.error("Error setting system prompt: %s", str(err))
            raise HomeAssistantError(f"Failed to set system prompt: {str(err)}")

+    # Register services
    hass.services.async_register(
        DOMAIN,
        SERVICE_ASK_QUESTION,
        async_ask_question,
-        schema=SERVICE_SCHEMA_ASK_QUESTION
+        schema=SERVICE_SCHEMA_ASK_QUESTION,
+        supports_response=True
    )

    hass.services.async_register(
@@ -178,13 +213,69 @@ async def async_setup(hass: HomeAssistant, config: Dict[str, Any]) -> bool:
        schema=SERVICE_SCHEMA_SET_SYSTEM_PROMPT
    )

+    # Handle icons
+    try:
+        source_icon_path = os.path.join(
+            os.path.dirname(__file__),
+            ICONS_SUBDOMAIN,
+            'icon@2x.png'
+        )
+
+        destination_directory = os.path.join(
+            hass.config.path('www'),
+            DOMAIN,
+            ICONS_SUBDOMAIN
+        )
+
+        destination_icon_path = os.path.join(
+            destination_directory,
+            'icon.png'
+        )
+
+        if not os.path.exists(source_icon_path):
+            _LOGGER.error("Source icon not found: %s", source_icon_path)
+            return True
+
+        def create_directory():
+            os.makedirs(destination_directory, exist_ok=True)
+
+        await hass.async_add_executor_job(create_directory)
+
+        should_copy = True
+
+        if os.path.exists(destination_icon_path):
+            source_hash = await hass.async_add_executor_job(get_file_hash, source_icon_path)
+            dest_hash = await hass.async_add_executor_job(get_file_hash, destination_icon_path)
+            should_copy = source_hash != dest_hash
+
+        if should_copy:
+            def copy_file():
+                shutil.copyfile(source_icon_path, destination_icon_path)
+
+            await hass.async_add_executor_job(copy_file)
+            _LOGGER.debug("Icon updated: %s", destination_icon_path)
+
+    except PermissionError as e:
+        _LOGGER.error("Permission denied when managing icons: %s", str(e))
+    except Exception as e:
+        _LOGGER.error("Failed to manage icons: %s", str(e))
+
    return True

 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"
        else:  # OpenAI
            check_url = f"{endpoint}/models"

@@ -193,7 +284,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
@@ -18,6 +19,9 @@ from .const import (
    API_TIMEOUT,
    API_RETRY_COUNT,
    API_PROVIDER_ANTHROPIC,
+    API_PROVIDER_DEEPSEEK,
+    API_PROVIDER_OPENAI,
+    API_PROVIDER_GEMINI,
    MIN_TEMPERATURE,
    MAX_TEMPERATURE,
    MIN_MAX_TOKENS,
@@ -45,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(
@@ -67,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):
@@ -80,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))
@@ -109,19 +134,53 @@ class APIClient:
                return await self._create_anthropic_completion(
                    model, messages, temperature, max_tokens
                )
+            elif self.api_provider == API_PROVIDER_DEEPSEEK:
+                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
                )
-        except (KeyError, IndexError) as e:
-            if "'choices'" in str(e) or "'message'" in str(e):
-                raise HomeAssistantError("Failed to get a response from the AI model. Please check your internet connection and try again later.")
-            else:
-                raise
        except Exception as e:
            _LOGGER.error("API request failed: %s", str(e))
            raise HomeAssistantError(f"API request failed: {str(e)}")

+    async def _create_deepseek_completion(
+        self,
+        model: str,
+        messages: List[Dict[str, str]],
+        temperature: float,
+        max_tokens: int,
+    ) -> Dict[str, Any]:
+        """Create completion using DeepSeek API."""
+        url = f"{self.endpoint}/chat/completions"
+        payload = {
+            "model": model,
+            "messages": messages,
+            "temperature": temperature,
+            "max_tokens": max_tokens,
+            "stream": False
+        }
+
+        data = await self._make_request(url, payload)
+        return {
+            "choices": [
+                {
+                    "message": {"content": data["choices"][0]["message"]["content"]},
+                }
+            ],
+            "usage": {
+                "prompt_tokens": data["usage"]["prompt_tokens"],
+                "completion_tokens": data["usage"]["completion_tokens"],
+                "total_tokens": data["usage"]["total_tokens"],
+            },
+        }
+
    async def _create_openai_completion(
        self,
        model: str,
@@ -206,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
@@ -28,13 +29,19 @@ from .const import (
    CONF_CONTEXT_MESSAGES,
    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,
@@ -90,9 +97,19 @@ class HATextAIConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
        self._errors = {}

        if user_input is None:
-            default_endpoint = (
-                DEFAULT_OPENAI_ENDPOINT if self._provider == API_PROVIDER_OPENAI
-                else DEFAULT_ANTHROPIC_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)
+
+            # 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(
@@ -100,7 +117,7 @@ class HATextAIConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
                data_schema=vol.Schema({
                    vol.Required(CONF_NAME, default="my_assistant"): str,
                    vol.Required(CONF_API_KEY): str,
-                    vol.Required(CONF_MODEL, default=DEFAULT_MODEL): str,
+                    vol.Required(CONF_MODEL, default=default_model): str,
                    vol.Required(CONF_API_ENDPOINT, default=default_endpoint): str,
                    vol.Optional(CONF_TEMPERATURE, default=DEFAULT_TEMPERATURE): vol.All(
                        vol.Coerce(float),
@@ -131,43 +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({
+                    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:
@@ -205,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))
@@ -230,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:
@@ -238,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"
@@ -250,6 +416,12 @@ 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_GEMINI_MODEL if self._provider == API_PROVIDER_GEMINI else
+            DEFAULT_MODEL
+        )
+
        entry_data = {
            CONF_API_PROVIDER: self._provider,
            CONF_NAME: instance_name,
@@ -257,7 +429,7 @@ class HATextAIConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
            CONF_API_KEY: user_input.get(CONF_API_KEY),
            CONF_API_ENDPOINT: user_input.get(CONF_API_ENDPOINT),
            "unique_id": unique_id,
-            CONF_MODEL: user_input.get(CONF_MODEL, DEFAULT_MODEL),
+            CONF_MODEL: user_input.get(CONF_MODEL, default_model),
            CONF_TEMPERATURE: user_input.get(CONF_TEMPERATURE, DEFAULT_TEMPERATURE),
            CONF_MAX_TOKENS: user_input.get(CONF_MAX_TOKENS, DEFAULT_MAX_TOKENS),
            CONF_REQUEST_INTERVAL: user_input.get(CONF_REQUEST_INTERVAL, DEFAULT_REQUEST_INTERVAL),
@@ -296,13 +468,20 @@ 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",
            data_schema=vol.Schema({
                vol.Optional(
                    CONF_MODEL,
-                    default=current_data.get(CONF_MODEL, DEFAULT_MODEL)
+                    default=current_data.get(CONF_MODEL, default_model)
                ): str,
                vol.Optional(
                    CONF_TEMPERATURE,
@@ -6,10 +6,14 @@ Constants for the HA text AI integration.
@github: https://github.com/smkrv/ha-text-ai
@source: https://github.com/smkrv/ha-text-ai
 """
+import os
+import json
 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"
@@ -19,15 +23,37 @@ PLATFORMS: list[str] = ["sensor"]
 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_ANTHROPIC,
+    API_PROVIDER_DEEPSEEK,
+    API_PROVIDER_GEMINI
 ]

+# Read version from manifest.json
+MANIFEST_PATH = os.path.join(os.path.dirname(__file__), "manifest.json")
+try:
+    with open(MANIFEST_PATH) as manifest_file:
+        manifest = json.load(manifest_file)
+        VERSION = manifest.get("version", "unknown")
+except FileNotFoundError:
+    VERSION = "unknown"
+    _LOGGER.warning("manifest.json not found at %s", MANIFEST_PATH)
+except json.JSONDecodeError as err:
+    VERSION = "unknown"
+    _LOGGER.error("Error decoding JSON from manifest.json: %s", err)
+except Exception as err:
+    VERSION = "unknown"
+    _LOGGER.error("Error reading manifest.json: %s", err)
+
 # Default endpoints
 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"
@@ -41,10 +67,14 @@ CONF_IS_ANTHROPIC: Final = "is_anthropic"
 CONF_CONTEXT_MESSAGES: Final = "context_messages"

 ABSOLUTE_MAX_HISTORY_SIZE = 500
-MAX_ENTRY_SIZE = 1 * 1024 * 1024
+MAX_ATTRIBUTE_SIZE = 4 * 1024
+MAX_HISTORY_FILE_SIZE = 1 * 1024 * 1024
+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
@@ -54,11 +84,13 @@ DEFAULT_NAME: Final = "HA Text AI"
 DEFAULT_NAME_PREFIX = "ha_text_ai"
 DEFAULT_CONTEXT_MESSAGES: Final = 5

+TRUNCATION_INDICATOR = " ... "
+
 # Parameter constraints
 MIN_TEMPERATURE: Final = 0.0
 MAX_TEMPERATURE: Final = 2.0
 MIN_MAX_TOKENS: Final = 1
-MAX_MAX_TOKENS: Final = 4096
+MAX_MAX_TOKENS: Final = 100000
 MIN_REQUEST_INTERVAL: Final = 0.1
 MAX_REQUEST_INTERVAL: Final = 60.0

@@ -16,6 +16,7 @@
  "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"
@@ -23,6 +24,6 @@
  "single_config_entry": false,
  "ssdp": [],
  "usb": [],
-  "version": "2.0.5-beta",
+  "version": "2.1.8",
  "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,
@@ -67,6 +68,8 @@ from .const import (
    ENTITY_ICON_PROCESSING,
    DEFAULT_NAME_PREFIX,
    CONF_MAX_HISTORY_SIZE,
+    MAX_ATTRIBUTE_SIZE,
+    VERSION,
 )

 from .coordinator import HATextAICoordinator
@@ -153,7 +156,7 @@ class HATextAISensor(CoordinatorEntity, SensorEntity):
            name=self._attr_name,
            manufacturer="Community",
            model=f"{model} ({api_provider} provider)",
-            sw_version="1.0.0",
+            sw_version=VERSION,
        )

        _LOGGER.debug(
@@ -178,12 +181,29 @@ class HATextAISensor(CoordinatorEntity, SensorEntity):

    def _sanitize_attributes(self, attributes: Dict[str, Any]) -> Dict[str, Any]:
        """Sanitize all attributes for JSON serialization."""
-        return {
+        sanitized = {
            key: self._sanitize_value(value)
            for key, value in attributes.items()
            if value is not None
        }

+        # Log metrics for debugging
+        metrics_keys = [
+            METRIC_TOTAL_TOKENS,
+            METRIC_PROMPT_TOKENS,
+            METRIC_COMPLETION_TOKENS,
+            METRIC_SUCCESSFUL_REQUESTS,
+            METRIC_FAILED_REQUESTS,
+            METRIC_AVERAGE_LATENCY,
+            METRIC_MAX_LATENCY,
+            METRIC_MIN_LATENCY,
+        ]
+
+        metrics_values = {k: sanitized.get(k) for k in metrics_keys if k in sanitized}
+        _LOGGER.debug(f"Metrics for {self.entity_id}: {metrics_values}")
+
+        return sanitized
+
    @property
    def native_value(self) -> StateType:
        """Return the native value of the sensor."""
@@ -212,68 +232,65 @@ class HATextAISensor(CoordinatorEntity, SensorEntity):

        try:
            data = self.coordinator.data
+            metrics = data.get("metrics", {})
+
+            # Base attributes
            attributes = {
                ATTR_MODEL: self._config_entry.data.get(CONF_MODEL, "Unknown"),
-                ATTR_API_PROVIDER: self._config_entry.data.get(
-                    CONF_API_PROVIDER, "Unknown"
-                ),
+                ATTR_API_PROVIDER: self._config_entry.data.get(CONF_API_PROVIDER, "Unknown"),
                ATTR_API_STATUS: self._current_state,
-                ATTR_TOTAL_ERRORS: self._error_count,
-                ATTR_LAST_ERROR: self._last_error,
+                ATTR_TOTAL_ERRORS: metrics.get("total_errors", 0),
                "instance_name": self._instance_name,
                "normalized_name": self._normalized_name,
-                ATTR_SYSTEM_PROMPT: data.get("system_prompt"),
+                ATTR_SYSTEM_PROMPT: (data.get("system_prompt", "")[:MAX_ATTRIBUTE_SIZE]
+                                   if data.get("system_prompt") else None),
                ATTR_IS_PROCESSING: data.get("is_processing", False),
                ATTR_IS_RATE_LIMITED: data.get("is_rate_limited", False),
                ATTR_IS_MAINTENANCE: data.get("is_maintenance", False),
                ATTR_ENDPOINT_STATUS: data.get("endpoint_status", "unknown"),
-                ATTR_UPTIME: data.get("uptime", 0),
+                ATTR_UPTIME: round(data.get("uptime", 0), 2),
                ATTR_HISTORY_SIZE: data.get("history_size", 0),
-                ATTR_CONVERSATION_HISTORY: data.get("conversation_history", []),
            }

-            # Add metrics
-            metrics = data.get("metrics", {})
-            if isinstance(metrics, dict):
-                self._metrics = metrics
-                attributes.update(
-                    {
-                        METRIC_TOTAL_TOKENS: metrics.get("total_tokens", 0),
-                        METRIC_PROMPT_TOKENS: metrics.get("prompt_tokens", 0),
-                        METRIC_COMPLETION_TOKENS: metrics.get("completion_tokens", 0),
-                        METRIC_SUCCESSFUL_REQUESTS: metrics.get(
-                            "successful_requests", 0
-                        ),
-                        METRIC_FAILED_REQUESTS: metrics.get("failed_requests", 0),
-                        METRIC_AVERAGE_LATENCY: metrics.get("average_latency", 0),
-                        METRIC_MAX_LATENCY: metrics.get("max_latency", 0),
-                        METRIC_MIN_LATENCY: metrics.get("min_latency", float("inf")),
+            # History limit
+            conversation_history = data.get("conversation_history", [])
+            if conversation_history:
+                limited_history = []
+                for entry in conversation_history:
+                    limited_entry = {
+                        "timestamp": entry["timestamp"],
+                        "question": entry["question"][:MAX_ATTRIBUTE_SIZE],
+                        "response": entry["response"][:MAX_ATTRIBUTE_SIZE]
                    }
-                )
+                    limited_history.append(limited_entry)
+                attributes[ATTR_CONVERSATION_HISTORY] = limited_history

-            # Add last response
+            # Metrics
+            if isinstance(metrics, dict):
+                attributes.update({
+                    METRIC_TOTAL_TOKENS: metrics.get("total_tokens", 0),
+                    METRIC_PROMPT_TOKENS: metrics.get("prompt_tokens", 0),
+                    METRIC_COMPLETION_TOKENS: metrics.get("completion_tokens", 0),
+                    METRIC_SUCCESSFUL_REQUESTS: metrics.get("successful_requests", 0),
+                    METRIC_FAILED_REQUESTS: metrics.get("failed_requests", 0),
+                    METRIC_AVERAGE_LATENCY: round(metrics.get("average_latency", 0), 2),
+                    METRIC_MAX_LATENCY: round(metrics.get("max_latency", 0), 2),
+                    METRIC_MIN_LATENCY: (metrics.get("min_latency")
+                                       if metrics.get("min_latency") != float("inf")
+                                       else None),
+                })
+
+            # Last response handling
            last_response = data.get("last_response", {})
            if isinstance(last_response, dict):
-                self._last_response = last_response
-                attributes.update(
-                    {
-                        ATTR_RESPONSE: last_response.get("response", ""),
-                        ATTR_QUESTION: last_response.get("question", ""),
-                        "last_model": last_response.get("model", ""),
-                        "last_timestamp": last_response.get("timestamp", ""),
-                        "last_error": last_response.get("error"),
-                    }
-                )
-
-            # Add performance metrics if available
-            if ATTR_PERFORMANCE_METRICS in data:
-                attributes[ATTR_PERFORMANCE_METRICS] = data[
-                    ATTR_PERFORMANCE_METRICS
-                ]
-
-            # Add API version if available
-            if ATTR_API_VERSION in data:
-                attributes[ATTR_API_VERSION] = data[ATTR_API_VERSION]
+                attributes.update({
+                    ATTR_RESPONSE: last_response.get("response", "")[:MAX_ATTRIBUTE_SIZE],
+                    ATTR_QUESTION: last_response.get("question", "")[:MAX_ATTRIBUTE_SIZE],
+                    "last_model": last_response.get("model", ""),
+                    "last_timestamp": last_response.get("timestamp", ""),
+                    "last_error": (last_response.get("error", "")[:MAX_ATTRIBUTE_SIZE]
+                                 if last_response.get("error") else None),
+                })

            return self._sanitize_attributes(attributes)

@@ -299,6 +316,12 @@ class HATextAISensor(CoordinatorEntity, SensorEntity):

            self._is_processing = data.get("is_processing", False)

+            # Update metrics
+            metrics = data.get("metrics", {})
+            if isinstance(metrics, dict):
+                self._metrics.update(metrics)
+                _LOGGER.debug(f"Updated metrics for {self.entity_id}: {self._metrics}")
+
            # Update conversation history and system prompt
            self._conversation_history = data.get("conversation_history", [])
            self._system_prompt = data.get("system_prompt")
@@ -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

@@ -19,7 +19,7 @@
          "model": "Zu verwendendes AI-Modell",
          "api_endpoint": "Benutzerdefinierte API-Endpunkt-URL (optional)",
          "temperature": "Kreativität der Antwort (0-2, niedriger = fokussierter)",
-          "max_tokens": "Maximale Länge der Antwort (1-4096 Token)",
+          "max_tokens": "Maximale Länge der Antwort (1-100000 Token)",
          "request_interval": "Minimale Zeit zwischen Anfragen (0,1-60 Sekunden)",
          "context_messages": "Anzahl der zu behaltenden Kontextnachrichten (1-20)",
          "max_history_size": "Maximale Größe des Gesprächsverlaufs (1-100)"
@@ -33,7 +33,7 @@
          "api_key": "API-Schlüssel zur Authentifizierung",
          "model": "Zu verwendendes AI-Modell",
          "temperature": "Kreativität der Antwort (0-2, niedriger = fokussierter)",
-          "max_tokens": "Maximale Länge der Antwort (1-4096 Token)",
+          "max_tokens": "Maximale Länge der Antwort (1-100000 Token)",
          "api_endpoint": "Benutzerdefinierte API-Endpunkt-URL (optional)",
          "api_provider": "API-Anbieter",
          "request_interval": "Minimale Zeit zwischen Anfragen (0,1-60 Sekunden)",
@@ -77,7 +77,7 @@
        "data": {
          "model": "AI-Modell",
          "temperature": "Kreativität der Antwort (0-2)",
-          "max_tokens": "Maximale Länge der Antwort (1-4096)",
+          "max_tokens": "Maximale Länge der Antwort (1-100000)",
          "request_interval": "Minimale Anfrageintervall (0,1-60 Sekunden)",
          "context_messages": "Anzahl der vorherigen Nachrichten, die im Kontext enthalten sein sollen (1-20)",
          "max_history_size": "Maximale Größe des Gesprächsverlaufs (1-100)"
@@ -88,15 +88,17 @@
  "selector": {
    "api_provider": {
      "options": {
-        "openai": "OpenAI (kompatibel)",
-        "anthropic": "Anthropic (kompatibel)"
+        "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",
@@ -124,7 +126,7 @@
        },
        "max_tokens": {
          "name": "Max Tokens",
-          "description": "Maximale Länge der Antwort (1-4096 Token)"
+          "description": "Maximale Länge der Antwort (1-100000 Token)"
        }
      }
    },
@@ -19,7 +19,7 @@
          "model": "AI model to use",
          "api_endpoint": "Custom API endpoint URL (optional)",
          "temperature": "Response creativity (0-2, lower = more focused)",
-          "max_tokens": "Maximum response length (1-4096 tokens)",
+          "max_tokens": "Maximum response length (1-100000 tokens)",
          "request_interval": "Minimum time between requests (0.1-60 seconds)",
          "context_messages": "Number of context messages to retain (1-20)",
          "max_history_size": "Maximum conversation history size (1-100)"
@@ -33,7 +33,7 @@
          "api_key": "API key for authentication",
          "model": "AI model to use",
          "temperature": "Response creativity (0-2, lower = more focused)",
-          "max_tokens": "Maximum response length (1-4096 tokens)",
+          "max_tokens": "Maximum response length (1-100000 tokens)",
          "api_endpoint": "Custom API endpoint URL (optional)",
          "api_provider": "API Provider",
          "request_interval": "Minimum time between requests (0.1-60 seconds)",
@@ -77,7 +77,7 @@
        "data": {
          "model": "AI model",
          "temperature": "Response creativity (0-2)",
-          "max_tokens": "Maximum response length (1-4096)",
+          "max_tokens": "Maximum response length (1-100000)",
          "request_interval": "Minimum request interval (0.1-60 seconds)",
          "context_messages": "Number of previous messages to include in context (1-20)",
          "max_history_size": "Maximum conversation history size (1-100)"
@@ -86,17 +86,19 @@
    }
  },
  "selector": {
-  "api_provider": {
-    "options": {
-      "openai": "OpenAI (compatible)",
-      "anthropic": "Anthropic (compatible)"
+    "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",
@@ -124,7 +126,7 @@
        },
        "max_tokens": {
          "name": "Max Tokens",
-          "description": "Maximum length of the response (1-4096 tokens)"
+          "description": "Maximum length of the response (1-100000 tokens)"
        }
      }
    },
@@ -19,7 +19,7 @@
          "model": "Modelo de IA a utilizar",
          "api_endpoint": "URL del endpoint de API personalizado (opcional)",
          "temperature": "Creatividad de la respuesta (0-2, menor = más enfocado)",
-          "max_tokens": "Longitud máxima de la respuesta (1-4096 tokens)",
+          "max_tokens": "Longitud máxima de la respuesta (1-100000 tokens)",
          "request_interval": "Tiempo mínimo entre solicitudes (0.1-60 segundos)",
          "context_messages": "Número de mensajes de contexto a retener (1-20)",
          "max_history_size": "Tamaño máximo del historial de conversación (1-100)"
@@ -33,7 +33,7 @@
          "api_key": "Clave API para autenticación",
          "model": "Modelo de IA a utilizar",
          "temperature": "Creatividad de la respuesta (0-2, menor = más enfocado)",
-          "max_tokens": "Longitud máxima de la respuesta (1-4096 tokens)",
+          "max_tokens": "Longitud máxima de la respuesta (1-100000 tokens)",
          "api_endpoint": "URL del endpoint de API personalizado (opcional)",
          "api_provider": "Proveedor de API",
          "request_interval": "Tiempo mínimo entre solicitudes (0.1-60 segundos)",
@@ -77,7 +77,7 @@
        "data": {
          "model": "Modelo de IA",
          "temperature": "Creatividad de la respuesta (0-2)",
-          "max_tokens": "Longitud máxima de la respuesta (1-4096)",
+          "max_tokens": "Longitud máxima de la respuesta (1-100000)",
          "request_interval": "Intervalo mínimo de solicitud (0.1-60 segundos)",
          "context_messages": "Número de mensajes anteriores a incluir en el contexto (1-20)",
          "max_history_size": "Tamaño máximo del historial de conversación (1-100)"
@@ -89,14 +89,16 @@
    "api_provider": {
      "options": {
        "openai": "OpenAI (compatible)",
-        "anthropic": "Anthropic (compatible)"
+        "anthropic": "Anthropic (compatible)",
+        "deepseek": "DeepSeek",
+        "gemini": "Google Gemini"
      }
    }
  },
  "services": {
    "ask_question": {
-      "name": "Hacer Pregunta (IA de Texto de HA)",
-      "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.",
+      "name": "Hacer Pregunta (HA Text AI)",
+      "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",
@@ -124,7 +126,7 @@
        },
        "max_tokens": {
          "name": "Máx. Tokens",
-          "description": "Longitud máxima de la respuesta (1-4096 tokens)"
+          "description": "Longitud máxima de la respuesta (1-100000 tokens)"
        }
      }
    },
@@ -1,15 +1,6 @@
 {
  "config": {
    "step": {
-      "provider": {
-        "title": "एआई प्रदाता चुनें",
-        "description": "इस उदाहरण के लिए किस एआई सेवा प्रदाता का उपयोग करना है, चुनें।",
-        "data": {
-          "api_provider": "एपीआई प्रदाता",
-          "context_messages": "रखने के लिए संदर्भ संदेशों की संख्या (1-20)",
-          "max_history_size": "अधिकतम बातचीत इतिहास आकार (1-100)"
-        }
-      },
      "provider": {
        "title": "प्रदाता सेटिंग्स",
        "description": "आपके द्वारा चुने गए एआई प्रदाता के लिए कनेक्शन विवरण प्रदान करें।",
@@ -19,7 +10,7 @@
          "model": "उपयोग करने के लिए एआई मॉडल",
          "api_endpoint": "कस्टम एपीआई एंडपॉइंट यूआरएल (वैकल्पिक)",
          "temperature": "प्रतिक्रिया की रचनात्मकता (0-2, कम = अधिक केंद्रित)",
-          "max_tokens": "प्रतिक्रिया की अधिकतम लंबाई (1-4096 टोकन)",
+          "max_tokens": "प्रतिक्रिया की अधिकतम लंबाई (1-100000 टोकन)",
          "request_interval": "अनुरोधों के बीच न्यूनतम समय (0.1-60 सेकंड)",
          "context_messages": "रखने के लिए संदर्भ संदेशों की संख्या (1-20)",
          "max_history_size": "अधिकतम बातचीत इतिहास आकार (1-100)"
@@ -33,7 +24,7 @@
          "api_key": "प्रमाणीकरण के लिए एपीआई कुंजी",
          "model": "उपयोग करने के लिए एआई मॉडल",
          "temperature": "प्रतिक्रिया की रचनात्मकता (0-2, कम = अधिक केंद्रित)",
-          "max_tokens": "प्रतिक्रिया की अधिकतम लंबाई (1-4096 टोकन)",
+          "max_tokens": "प्रतिक्रिया की अधिकतम लंबाई (1-100000 टोकन)",
          "api_endpoint": "कस्टम एपीआई एंडपॉइंट यूआरएल (वैकल्पिक)",
          "api_provider": "एपीआई प्रदाता",
          "request_interval": "अनुरोधों के बीच न्यूनतम समय (0.1-60 सेकंड)",
@@ -77,7 +68,7 @@
        "data": {
          "model": "एआई मॉडल",
          "temperature": "प्रतिक्रिया की रचनात्मकता (0-2)",
-          "max_tokens": "प्रतिक्रिया की अधिकतम लंबाई (1-4096)",
+          "max_tokens": "प्रतिक्रिया की अधिकतम लंबाई (1-100000)",
          "request_interval": "न्यूनतम अनुरोध अंतराल (0.1-60 सेकंड)",
          "context_messages": "संदर्भ में शामिल करने के लिए पिछले संदेशों की संख्या (1-20)",
          "max_history_size": "अधिकतम बातचीत इतिहास आकार (1-100)"
@@ -89,14 +80,16 @@
    "api_provider": {
      "options": {
        "openai": "OpenAI (अनुकूलित)",
-        "anthropic": "Anthropic (अनुकूलित)"
+        "anthropic": "Anthropic (अनुकूलित)",
+        "deepseek": "DeepSeek",
+        "gemini": "Google Gemini"
      }
    }
  },
  "services": {
    "ask_question": {
-      "name": "प्रश्न पूछें (एचए टेक्स्ट एआई)",
-      "description": "एआई मॉडल को एक प्रश्न भेजें और विस्तृत प्रतिक्रिया प्राप्त करें। प्रतिक्रिया बातचीत के इतिहास में संग्रहीत की जाएगी और बाद में पुनर्प्राप्त की जा सकती है।",
+      "name": "प्रश्न पूछें (HA Text AI)",
+      "description": "AI मॉडल को प्रश्न भेजें और विस्तृत उत्तर प्राप्त करें। यह सेवा अब प्रत्यक्ष रूप से प्रतिक्रिया डेटा वापस करती है, अलग टेक्स्ट सेंसर की आवश्यकता और 255 वर्ण की सीमा को समाप्त करती है। प्रतिक्रिया को बातचीत के इतिहास में भी संग्रहीत किया जाएगा।",
      "fields": {
        "instance": {
          "name": "उदाहरण",
@@ -124,7 +117,7 @@
        },
        "max_tokens": {
          "name": "अधिकतम टोकन",
-          "description": "प्रतिक्रिया की अधिकतम लंबाई (1-4096 टोकन)"
+          "description": "प्रतिक्रिया की अधिकतम लंबाई (1-100000 टोकन)"
        }
      }
    },
@@ -293,4 +286,4 @@
      }
    }
  }
-}
+}
@@ -19,7 +19,7 @@
          "model": "Modello AI da utilizzare",
          "api_endpoint": "URL dell'endpoint API personalizzato (opzionale)",
          "temperature": "Creatività della risposta (0-2, più basso = più focalizzato)",
-          "max_tokens": "Lunghezza massima della risposta (1-4096 token)",
+          "max_tokens": "Lunghezza massima della risposta (1-100000 token)",
          "request_interval": "Tempo minimo tra le richieste (0.1-60 secondi)",
          "context_messages": "Numero di messaggi di contesto da mantenere (1-20)",
          "max_history_size": "Dimensione massima della cronologia delle conversazioni (1-100)"
@@ -33,7 +33,7 @@
          "api_key": "Chiave API per l'autenticazione",
          "model": "Modello AI da utilizzare",
          "temperature": "Creatività della risposta (0-2, più basso = più focalizzato)",
-          "max_tokens": "Lunghezza massima della risposta (1-4096 token)",
+          "max_tokens": "Lunghezza massima della risposta (1-100000 token)",
          "api_endpoint": "URL dell'endpoint API personalizzato (opzionale)",
          "api_provider": "Fornitore API",
          "request_interval": "Tempo minimo tra le richieste (0.1-60 secondi)",
@@ -77,7 +77,7 @@
        "data": {
          "model": "Modello AI",
          "temperature": "Creatività della risposta (0-2)",
-          "max_tokens": "Lunghezza massima della risposta (1-4096)",
+          "max_tokens": "Lunghezza massima della risposta (1-100000)",
          "request_interval": "Intervallo minimo di richiesta (0.1-60 secondi)",
          "context_messages": "Numero di messaggi precedenti da includere nel contesto (1-20)",
          "max_history_size": "Dimensione massima della cronologia delle conversazioni (1-100)"
@@ -89,14 +89,16 @@
    "api_provider": {
      "options": {
        "openai": "OpenAI (compatibile)",
-        "anthropic": "Anthropic (compatibile)"
+        "anthropic": "Anthropic (compatibile)",
+        "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",
@@ -124,7 +126,7 @@
        },
        "max_tokens": {
          "name": "Token massimi",
-          "description": "Lunghezza massima della risposta (1-4096 token)"
+          "description": "Lunghezza massima della risposta (1-100000 token)"
        }
      }
    },
@@ -19,7 +19,7 @@
          "model": "Модель ИИ для использования",
          "api_endpoint": "Пользовательский URL-адрес конечной точки API (необязательно)",
          "temperature": "Креативность ответа (0-2, меньше = более сфокусированно)",
-          "max_tokens": "Максимальная длина ответа (1-4096 токенов)",
+          "max_tokens": "Максимальная длина ответа (1-100000 токенов)",
          "request_interval": "Минимальный интервал между запросами (0.1-60 секунд)",
          "context_messages": "Количество сохраняемых контекстных сообщений (1-20)",
          "max_history_size": "Максимальный размер истории разговора (1-100)"
@@ -33,7 +33,7 @@
          "api_key": "API-ключ для аутентификации",
          "model": "Модель ИИ для использования",
          "temperature": "Креативность ответа (0-2, меньше = более сфокусированно)",
-          "max_tokens": "Максимальная длина ответа (1-4096 токенов)",
+          "max_tokens": "Максимальная длина ответа (1-100000 токенов)",
          "api_endpoint": "Пользовательский URL-адрес конечной точки API (необязательно)",
          "api_provider": "Провайдер API",
          "request_interval": "Минимальный интервал между запросами (0.1-60 секунд)",
@@ -77,7 +77,7 @@
        "data": {
          "model": "Модель ИИ",
          "temperature": "Креативность ответа (0-2)",
-          "max_tokens": "Максимальная длина ответа (1-4096)",
+          "max_tokens": "Максимальная длина ответа (1-100000)",
          "request_interval": "Минимальный интервал между запросами (0.1-60 секунд)",
          "context_messages": "Количество предыдущих сообщений для включения в контекст (1-20)",
          "max_history_size": "Максимальный размер истории разговора (1-100)"
@@ -89,14 +89,16 @@
    "api_provider": {
      "options": {
        "openai": "OpenAI (совместимый)",
-        "anthropic": "Anthropic (совместимый)"
+        "anthropic": "Anthropic (совместимый)",
+        "deepseek": "DeepSeek",
+        "gemini": "Google Gemini"
      }
    }
  },
  "services": {
    "ask_question": {
-      "name": "Задать вопрос (Текстовый ИИ HA)",
-      "description": "Отправить вопрос модели ИИ и получить подробный ответ. Ответ будет сохранен в истории разговора и может быть получен позже.",
+      "name": "Задать вопрос (HA Text AI)",
+      "description": "Отправить вопрос модели ИИ и получить подробный ответ. Сервис теперь возвращает данные ответа напрямую, устраняя необходимость в отдельных текстовых сенсорах и ограничение в 255 символов. Ответ также будет сохранен в истории разговора.",
      "fields": {
        "instance": {
          "name": "Экземпляр",
@@ -124,7 +126,7 @@
        },
        "max_tokens": {
          "name": "Максимум токенов",
-          "description": "Максимальная длина ответа (1-4096 токенов)"
+          "description": "Максимальная длина ответа (1-100000 токенов)"
        }
      }
    },
@@ -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 провајдера.",
@@ -19,7 +10,7 @@
          "model": "AI модел који ће се користити",
          "api_endpoint": "Прилагођени URL API крајње тачке (опционо)",
          "temperature": "Креативност одговора (0-2, нижа = фокусираније)",
-          "max_tokens": "Максимална дужина одговора (1-4096 токена)",
+          "max_tokens": "Максимална дужина одговора (1-100000 токена)",
          "request_interval": "Минимално време између захтева (0.1-60 секунди)",
          "context_messages": "Број контекстуалних порука које треба задржати (1-20)",
          "max_history_size": "Максимална величина историје разговора (1-100)"
@@ -33,7 +24,7 @@
          "api_key": "API кључ за аутентификацију",
          "model": "AI модел који ће се користити",
          "temperature": "Креативност одговора (0-2, нижа = фокусираније)",
-          "max_tokens": "Максимална дужина одговора (1-4096 токена)",
+          "max_tokens": "Максимална дужина одговора (1-100000 токена)",
          "api_endpoint": "Прилагођени URL API крајње тачке (опционо)",
          "api_provider": "API провајдер",
          "request_interval": "Минимално време између захтева (0.1-60 секунди)",
@@ -77,7 +68,7 @@
        "data": {
          "model": "AI модел",
          "temperature": "Креативност одговора (0-2)",
-          "max_tokens": "Максимална дужина одговора (1-4096)",
+          "max_tokens": "Максимална дужина одговора (1-100000)",
          "request_interval": "Минимално време између захтева (0.1-60 секунди)",
          "context_messages": "Број претходних порука које треба укључити у контекст (1-20)",
          "max_history_size": "Максимална величина историје разговора (1-100)"
@@ -89,14 +80,16 @@
    "api_provider": {
      "options": {
        "openai": "OpenAI (компатибилан)",
-        "anthropic": "Anthropic (компатибилан)"
+        "anthropic": "Anthropic (компатибилан)",
+        "deepseek": "DeepSeek",
+        "gemini": "Google Gemini"
      }
    }
  },
  "services": {
    "ask_question": {
      "name": "Поставите питање (HA Text AI)",
-      "description": "Пошаљите питање AI моделу и примите детаљан одговор. Одговор ће бити сачуван у историји разговора и може се касније повратити.",
+      "description": "Пошаљите питање AI моделу и добијте детаљан одговор. Овај сервис сада враћа податке одговора директно, елиминишући потребу за засебним текстуалним сензорима и ограничење од 255 карактера. Одговор ће такође бити сачуван у историји разговора.",
      "fields": {
        "instance": {
          "name": "Инстанца",
@@ -124,7 +117,7 @@
        },
        "max_tokens": {
          "name": "Максимални токени",
-          "description": "Максимална дужина одговора (1-4096 токена)"
+          "description": "Максимална дужина одговора (1-100000 токена)"
        }
      }
    },
@@ -293,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提供者的连接详细信息。",
@@ -19,7 +10,7 @@
          "model": "要使用的AI模型",
          "api_endpoint": "自定义API端点URL（可选）",
          "temperature": "响应创造力（0-2，越低越专注）",
-          "max_tokens": "最大响应长度（1-4096个标记）",
+          "max_tokens": "最大响应长度（1-100000个标记）",
          "request_interval": "请求之间的最小时间（0.1-60秒）",
          "context_messages": "保留的上下文消息数量（1-20）",
          "max_history_size": "最大对话历史大小（1-100）"
@@ -33,7 +24,7 @@
          "api_key": "用于身份验证的API密钥",
          "model": "要使用的AI模型",
          "temperature": "响应创造力（0-2，越低越专注）",
-          "max_tokens": "最大响应长度（1-4096个标记）",
+          "max_tokens": "最大响应长度（1-100000个标记）",
          "api_endpoint": "自定义API端点URL（可选）",
          "api_provider": "API提供者",
          "request_interval": "请求之间的最小时间（0.1-60秒）",
@@ -77,7 +68,7 @@
        "data": {
          "model": "AI模型",
          "temperature": "响应创造力（0-2）",
-          "max_tokens": "最大响应长度（1-4096）",
+          "max_tokens": "最大响应长度（1-100000）",
          "request_interval": "最小请求间隔（0.1-60秒）",
          "context_messages": "要包含在上下文中的先前消息数量（1-20）",
          "max_history_size": "最大对话历史大小（1-100）"
@@ -89,14 +80,16 @@
    "api_provider": {
      "options": {
        "openai": "OpenAI（兼容）",
-        "anthropic": "Anthropic（兼容）"
+        "anthropic": "Anthropic（兼容）",
+        "deepseek": "DeepSeek",
+        "gemini": "Google Gemini"
      }
    }
  },
  "services": {
    "ask_question": {
-      "name": "提问（HA文本AI）",
-      "description": "向AI模型发送问题并接收详细响应。响应将存储在对话历史中，可以稍后检索。",
+      "name": "提问 (HA Text AI)",
+      "description": "向AI模型发送问题并获得详细回答。此服务现在直接返回响应数据，消除了对单独文本传感器的需要和255字符限制。响应也将存储在对话历史中。",
      "fields": {
        "instance": {
          "name": "实例",
@@ -124,7 +117,7 @@
        },
        "max_tokens": {
          "name": "最大标记数",
-          "description": "响应的最大长度（1-4096个标记）"
+          "description": "响应的最大长度（1-100000个标记）"
        }
      }
    },
@@ -293,4 +286,4 @@
      }
    }
  }
-}
+}
@@ -1,5 +1,5 @@
 {
-  "name": "HA text AI",
+  "name": "HA Text AI",
  "render_readme": true,
  "homeassistant": "2024.11.0"
 }
@@ -1,25 +1,30 @@
 ```
-ha-text-ai/
-│
-├── custom_components/
-    ├── ha_text_ai/
-    │   ├── __init__.py
-    │   ├── config_flow.py
-    │   ├── coordinator.py
-    │   ├── manifest.json
-    │   ├── sensor.py
-    │   ├── services.yaml
-    │   ├── const.py
-    │   └── api_client.py
-    │
-    ├── translations/
-    │   ├── en.json
-    │   ├── de.json
-    │   └── ru.json
-    │
-    └── icons/
-        ├── icon.png
-        ├── icon@2x.png
-        ├── logo.png
-        └── logo@2x.png
+ha_text_ai/
+├── __init__.py
+├── api_client.py
+├── config_flow.py
+├── const.py
+├── coordinator.py
+├── icons
+│   ├── dark_icon.png
+│   ├── dark_icon@2x.png
+│   ├── dark_logo.png
+│   ├── dark_logo@2x.png
+│   ├── icon.png
+│   ├── icon@2x.png
+│   ├── logo.png
+│   └── logo@2x.png
+├── manifest.json
+├── sensor.py
+├── services.yaml
+└── translations
+    ├── de.json
+    ├── en.json
+    ├── es.json
+    ├── hi.json
+    ├── it.json
+    ├── ru.json
+    ├── sr.json
+    └── zh.json
+
 ```
Author	SHA1	Message	Date
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
SMKRV	bfd64d1122	Release v2.1.1: Token Handling Improvement and DeepSeek Support - Completely reworked token handling mechanism - Removed custom token calculation logic - Direct max_tokens passing to LLM APIs - Added support for DeepSeek provider - Integrated deepseek-chat and deepseek-reasoner models Thanks to @estiens for reporting token handling issues and providing valuable feedback (https://github.com/smkrv/ha-text-ai/issues/1).	2025-01-28 15:54:48 +03:00
SMKRV	82e1f0c4f9	Release v2.1.0	2024-12-13 00:06:08 +03:00
SMKRV	5c16eee6e4	fix: Read version from manifest.json	2024-12-12 16:03:15 +03:00
SMKRV	e988d445a4	- Fixed version reading from manifest.json implementation	2024-12-11 22:01:01 +03:00
SMKRV	f9bfb9ab7f	fix: correct sw_version syntax in device_info - Fixed version reading from manifest.json implementation	2024-12-11 21:57:27 +03:00
SMKRV	92dd1bc110	~	2024-12-11 00:00:12 +03:00
SMKRV	17d547325a	refactor(docs): updated README services examples with more detailed configuration	2024-12-10 23:33:32 +03:00
SMKRV	b8cb70217c	refactor(docs): updated README shields	2024-12-10 23:27:49 +03:00
SMKRV	530d04f25d	refactor(docs): updated README shields	2024-12-10 23:27:18 +03:00
SMKRV	b71083b9bf	bump to version 2.0.9	2024-12-10 17:25:47 +03:00
SMKRV	f9f7d10f7f	refactor(docs): updated README images	2024-12-10 17:21:41 +03:00
SMKRV	9f7cb20621	refactor(docs): updated README images	2024-12-10 17:19:52 +03:00
SMKRV	6fc3b23365	refactor(docs): updated README images	2024-12-10 17:18:55 +03:00
SMKRV	15c717fcb0	fix: Display only last Q&A in sensor state to prevent data truncation - Show only the latest question and answer in sensor state - Keep full conversation history in attributes - Fix truncation issues in Home Assistant UI - Maintain backwards compatibility - No configuration changes required	2024-12-10 17:02:48 +03:00
SMKRV	be06fddce1	fix: Display only last Q&A in sensor state to prevent data truncation - Show only the latest question and answer in sensor state - Keep full conversation history in attributes - Fix truncation issues in Home Assistant UI - Maintain backwards compatibility - No configuration changes required	2024-12-10 16:19:17 +03:00
SMKRV	5f0bd861a7	docs(readme): Included note that the integration has been submitted to HACS store and is currently pending review in pull request: [pull request #2896 ](hacs/default#2896 ).	2024-12-10 00:00:18 +03:00
SMKRV	428aee46c8	docs(readme): Included note that the integration has been submitted to HACS store and is currently pending review in pull request: [pull request #2896 ](hacs/default#2896 ).	2024-12-09 23:59:51 +03:00
SMKRV	561bcf0b1d	docs(Code of Conduct): Add Code of Conduct to promote community guidelines - Implement Contributor Covenant Code of Conduct v1.4 - Establish clear expectations for community interactions - Define standards of acceptable and unacceptable behavior - Provide framework for reporting and addressing issues - Emphasize inclusivity and respect for all contributors	2024-12-09 16:52:44 +03:00
SMKRV	2b1e42c665	docs(readme): Included note that the integration has been submitted to HACS store and is currently pending review in pull request: [pull request #2893 ](https://github.com/hacs/default/pull/2893 ).	2024-12-09 15:29:53 +03:00
SMKRV	2d68f29ab5	bump to version 2.0.8	2024-12-09 00:41:28 +03:00
SMKRV	19d4a93bca	bump to version 2.0.8	2024-12-09 00:41:08 +03:00
SMKRV	fb75c5f44e	bump to version 2.0.9	2024-12-09 00:39:28 +03:00
SMKRV	52af987985	bump to version 2.0.9	2024-12-09 00:38:59 +03:00
SMKRV	162a30acdd	bump to version 2.0.8-beta	2024-12-07 00:48:17 +03:00
SMKRV	898a6fc638	bump to version 2.0.8-beta	2024-12-07 00:43:53 +03:00
SMKRV	38e2362be4	bump to version 2.0.8-beta	2024-12-06 16:51:32 +03:00
SMKRV	cea912d0b5	bump to version 2.0.8-beta	2024-12-06 16:51:09 +03:00
SMKRV	5ec00040c2	bump to version 2.0.8-beta	2024-12-06 16:50:26 +03:00
SMKRV	8d28fc4a0d	bump to version 2.0.8-beta	2024-12-06 16:46:11 +03:00
SMKRV	7cc6587724	bump to version 2.0.8-beta	2024-12-06 16:35:26 +03:00
SMKRV	bacf76e0a9	bump to version 2.0.8-beta	2024-12-06 16:33:46 +03:00
SMKRV	f86c7bfd57	refactor(docs): relocate README images from misc/ to assets/	2024-12-06 16:13:27 +03:00
SMKRV	2aaf340575	refactor(docs): relocate README images from misc/ to assets/	2024-12-06 16:11:13 +03:00
SMKRV	bae11ba85c	refactor(docs): relocate README images from misc/ to assets/	2024-12-06 16:10:04 +03:00
SMKRV	9eb7d8912c	fix: sensor history attribute calculation	2024-12-06 12:26:56 +03:00
SMKRV	d29535245f	Release v2.0.7-beta	2024-12-06 12:00:23 +03:00
SMKRV	ca3ae982b0	feat(performance): Optimize system resources and token estimation - Improve JSON history file processing - Add memory and disk space validation - Enhance parallel request handling - Refine token counting heuristics	2024-12-06 03:14:52 +03:00
SMKRV	0c4399b46c	feat(performance): Optimize system resources and token estimation - Improve JSON history file processing - Add memory and disk space validation - Enhance parallel request handling - Refine token counting heuristics	2024-12-06 02:53:41 +03:00
SMKRV	c13ef1921d	feat(performance): Optimize system resources and token estimation - Improve JSON history file processing - Add memory and disk space validation - Enhance parallel request handling - Refine token counting heuristics	2024-12-06 02:51:06 +03:00
SMKRV	0fb9acfa8f	docs:(README)	2024-12-05 02:00:24 +03:00
SMKRV	2ac4389e1a	docs:(README)	2024-12-05 01:55:31 +03:00
SMKRV	de194e425c	docs:(README)	2024-12-05 01:54:09 +03:00
SMKRV	95f3d6506e	docs:(README)	2024-12-05 01:49:26 +03:00
SMKRV	3e877243b9	docs:(README)	2024-12-05 01:46:28 +03:00
SMKRV	fd795c9e90	docs:(readme)	2024-12-05 00:36:08 +03:00
SMKRV	5f5dc041b9	docs: structure	2024-12-04 23:32:05 +03:00
SMKRV	3d3885d43d	Update README.md	2024-12-04 23:28:14 +03:00
smkrvandGitHub	b059744716	Update README.md	2024-12-04 23:23:46 +03:00
SMKRV	f2a41aaa2c	docs: logo	2024-12-04 20:13:08 +03:00
SMKRV	1fcf751d0d	docs: logo	2024-12-04 19:24:30 +03:00
SMKRV	a45c9407fd	docs: logo	2024-12-04 19:19:40 +03:00
SMKRV	21fdf108cf	docs: logo	2024-12-04 19:17:09 +03:00
SMKRV	c7ec2b3ea4	docs: logo	2024-12-04 19:13:57 +03:00
SMKRV	6c4da6cea5	docs: logo	2024-12-04 19:12:44 +03:00
SMKRV	3029c5dd26	docs: logo	2024-12-04 19:12:21 +03:00
SMKRV	3e97028094	docs: logo	2024-12-04 19:11:54 +03:00
SMKRV	1194c87134	docs: logo	2024-12-04 17:51:40 +03:00
SMKRV	e03b5315c2	logo update	2024-12-04 17:51:02 +03:00
SMKRV	fad887492f	docs: logo	2024-12-04 17:48:04 +03:00
SMKRV	f26df29937	docs: logo	2024-12-04 17:47:12 +03:00
SMKRV	69b54a08ba	logo update	2024-12-04 17:42:32 +03:00
SMKRV	7ce77eb18e	docs: logo	2024-12-04 17:36:18 +03:00
SMKRV	1480669dc8	icons update	2024-12-04 17:34:19 +03:00