Release v2.0.4-beta

- Added translations for:
  * Chinese (zh)
  * Serbian (sr)
  * Italian (it)
  * Hindi (hi)
  * Spanish (es)

- Fixed minor bugs
- Improved language coverage

.github/ISSUE_TEMPLATE/bug_report.md

@@ -3,7 +3,7 @@ name: Bug report
 about: Create a report to help us improve
 title: ''
 labels: bug
-assignees: ''
+assignees: '' 
 
 ---
 

.github/ISSUE_TEMPLATE/feature_request.md

@@ -3,7 +3,7 @@ name: Feature request
 about: Suggest an idea for this project
 title: ''
 labels: enhancement
-assignees: ''
+assignees: '' 
 
 ---
 

.github/workflows/validate.yaml

@@ -0,0 +1,17 @@
+name: Validate
+
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: "0 0 * * *"
+  workflow_dispatch:
+
+jobs:
+  validate-hacs:
+    runs-on: "ubuntu-latest"
+    steps:
+      - name: HACS validation
+        uses: "hacs/action@main"
+        with:
+          category: "integration"

.gitignore

@@ -37,3 +37,4 @@ wheels/
 Thumbs.db
 *.psd
 *.zip
+*.txt

CONTRIBUTING.md

@@ -21,7 +21,7 @@ We welcome contributions to the HA Text AI project! This document will help you
    git remote add upstream https://github.com/smkrv/ha-text-ai.git
    ```
 
-### 2. Creating a Development Branch
+### 2. Creating a Development Branch 
 
 ```bash
 # Update the main branch

LICENSE

@@ -1,22 +1,437 @@
-MIT License
+Attribution-NonCommercial-ShareAlike 4.0 International
 
-Copyright (c) 2024 smkrv
+=======================================================================
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+Using Creative Commons Public Licenses
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
- 
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+    wiki.creativecommons.org/Considerations_for_licensors
+
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More considerations
+     for the public:
+    wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
+Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution-NonCommercial-ShareAlike 4.0 International Public License
+("Public License"). To the extent this Public License may be
+interpreted as a contract, You are granted the Licensed Rights in
+consideration of Your acceptance of these terms and conditions, and the
+Licensor grants You such rights in consideration of benefits the
+Licensor receives from making the Licensed Material available under
+these terms and conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. BY-NC-SA Compatible License means a license listed at
+     creativecommons.org/compatiblelicenses, approved by Creative
+     Commons as essentially the equivalent of this Public License.
+
+  d. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  e. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  f. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  g. License Elements means the license attributes listed in the name
+     of a Creative Commons Public License. The License Elements of this
+     Public License are Attribution, NonCommercial, and ShareAlike.
+
+  h. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  i. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  j. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  k. NonCommercial means not primarily intended for or directed towards
+     commercial advantage or monetary compensation. For purposes of
+     this Public License, the exchange of the Licensed Material for
+     other material subject to Copyright and Similar Rights by digital
+     file-sharing or similar means is NonCommercial provided there is
+     no payment of monetary compensation in connection with the
+     exchange.
+
+  l. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  m. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  n. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part, for NonCommercial purposes only; and
+
+            b. produce, reproduce, and Share Adapted Material for
+               NonCommercial purposes only.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. Additional offer from the Licensor -- Adapted Material.
+               Every recipient of Adapted Material from You
+               automatically receives an offer from the Licensor to
+               exercise the Licensed Rights in the Adapted Material
+               under the conditions of the Adapter's License You apply.
+
+            c. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties, including when
+          the Licensed Material is used other than for NonCommercial
+          purposes.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+  b. ShareAlike.
+
+     In addition to the conditions in Section 3(a), if You Share
+     Adapted Material You produce, the following conditions also apply.
+
+       1. The Adapter's License You apply must be a Creative Commons
+          license with the same License Elements, this version or
+          later, or a BY-NC-SA Compatible License.
+
+       2. You must include the text of, or the URI or hyperlink to, the
+          Adapter's License You apply. You may satisfy this condition
+          in any reasonable manner based on the medium, means, and
+          context in which You Share Adapted Material.
+
+       3. You may not offer or impose any additional or different terms
+          or conditions on, or apply any Effective Technological
+          Measures to, Adapted Material that restrict exercise of the
+          rights granted under the Adapter's License You apply.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database for NonCommercial purposes
+     only;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material,
+     including for purposes of Section 3(b); and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.

README.md

@@ -2,22 +2,28 @@
 
 <div align="center">  
 
-  ![GitHub release](https://img.shields.io/github/release/smkrv/ha-text-ai.svg?style=flat-square) ![GitHub downloads](https://img.shields.io/github/downloads/smkrv/ha-text-ai/total.svg?style=flat-square) ![GitHub stars](https://img.shields.io/github/stars/smkrv/ha-text-ai.svg?style=social) ![GitHub last commit](https://img.shields.io/github/last-commit/smkrv/ha-text-ai.svg?style=flat-square) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT) [![hacs_badge](https://img.shields.io/badge/HACS-Custom-41BDF5.svg?style=flat-square)](https://github.com/hacs/integration)
+![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: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](https://opensource.org/licenses/MIT) [![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)
 
-  <img src="https://github.com/smkrv/ha-text-ai/blob/3e3ec45b195c92989434fde40ae110027f4ea124/misc/icons/icon.png" alt="HA Text AI" width="140"/>
+  <img src="https://github.com/smkrv/ha-text-ai/blob/524849f6a945ec62c2cf6a6b7ecd9a28b37bf0fa/misc/icons/logo.jpg" alt="HA Text AI" height="160"/>
 
-### Advanced AI Integration for Home Assistant with multi-provider support
+### 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.
+
 </p>
 
 ---
-> [!NOTE]
+
+> [!IMPORTANT]
 > 🚧 ALPHA VERSION 🚧  
-> Expect: potential bugs, frequent changes, incomplete features.
-> 🤝 Community Driven
+> Expect: potential bugs, frequent changes, incomplete features.  
+> 🤝 Community Driven  
+>
+>  <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>  
+>  
+> [Screenshots](misc/screenshots/screenshot.jpg)
 
 ## 🌟 Features
 
@@ -71,7 +77,7 @@ Transform your smart home experience with powerful AI assistance powered by mult
 
 ## 📋 Prerequisites
 
-- Home Assistant 2023.11 or later
+- Home Assistant 2024.11 or later
 - Active API key from:
   - OpenAI ([Get key](https://platform.openai.com/account/api-keys))
   - Anthropic ([Get key](https://console.anthropic.com/))
@@ -139,20 +145,61 @@ To be compatible, a provider should support:
 4. Follow the configuration steps
 
 ### Via YAML
+
+### Platform Configuration (Global Settings)
+
 ```yaml
 ha_text_ai:
-  api_provider: openai  # or anthropic
-  api_key: !secret ai_api_key
-  model: gpt-4o-mini
-  temperature: 0.7
-  max_tokens: 1000
-  request_interval: 1.0
-  api_endpoint: https://api.openai.com/v1  # optional, for custom endpoints
-  system_prompt: |
+  api_provider: openai  # Required
+  api_key: !secret ai_api_key  # Required
+  model: gpt-4o-mini  # Strongly recommended
+  temperature: 0.7  # Optional
+  max_tokens: 1000  # Optional
+  request_interval: 1.0  # Optional
+  api_endpoint: https://api.openai.com/v1  # Required
+  system_prompt: |  # Optional
     You are a home automation expert assistant.
     Focus on practical and efficient solutions.
 ```
 
+### Sensor Configuration
+
+```yaml
+sensor:
+  - platform: ha_text_ai
+    name: "My AI Assistant"  # Required, unique identifier
+    api_provider: openai  # Optional (inherits from platform)
+    model: "gpt-4o-mini"  # Optional
+    temperature: 0.7  # Optional
+    max_tokens: 1000  # Optional
+```
+
+### 📋 Configuration Parameters
+
+#### Platform Configuration
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `api_provider` | String | ✅ | - | AI service provider (openai, anthropic) |
+| `api_key` | String | ✅ | - | Authentication key for AI service |
+| `model` | String | ⚠️ | Provider default | Strongly recommended: Specific AI model to use. If not specified, the provider's default model will be used |
+| `temperature` | Float | ❌ | 0.7 | Response creativity level (0.0-2.0) |
+| `max_tokens` | Integer | ❌ | 1000 | Maximum response length |
+| `request_interval` | Float | ❌ | 1.0 | Delay between API requests |
+| `api_endpoint` | URL | ⚠️ | Provider default | Custom API endpoint |
+| `system_prompt` | String | ❌ | - | Default context for AI interactions |
+
+#### Sensor Configuration
+
+| Parameter | Type | Required | Default | Description |
+|-----------|------|----------|---------|-------------|
+| `platform` | String | ✅ | - | Must be `ha_text_ai` |
+| `name` | String | ✅ | - | Unique sensor identifier |
+| `api_provider` | String | ❌ | Platform setting | Override global provider |
+| `model` | String | ⚠️ | Platform setting | Recommended: Override global model. If not specified, uses platform or provider default |
+| `temperature` | Float | ❌ | Platform setting | Override global temperature |
+| `max_tokens` | Integer | ❌ | Platform setting | Override global max tokens |
+
 ## 🛠️ Available Services
 
 ### ask_question
@@ -192,6 +239,143 @@ data:
   filter_model: "gpt-4o"  # optional
 ```
 
+### 🏷️ HA Text AI Sensor Naming Convention
+
+#### Character Restrictions  
+- Only lowercase letters (a-z)  
+- Numbers (0-9)  
+- Underscore (_)  
+- Maximum length: 50 characters (including `ha_text_ai_`)
+
+#### Sensor Name Structure
+```yaml
+# Always starts with 'sensor.ha_text_ai_'
+# You define only the part after the underscore
+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
+```
+
+#### Response Retrieval
+```yaml
+# Use your specific sensor name
+{{ state_attr('sensor.ha_text_ai_gpt', 'response') }}
+```
+
+#### Practical Usage
+```yaml
+automation:
+  - alias: "AI Response with Custom Sensor"
+    action:
+      - service: ha_text_ai.ask_question
+        data:
+          question: "Home automation advice"
+      - service: notify.mobile
+        data:
+          message: >
+            AI Tip:
+            {{ state_attr('sensor.ha_text_ai_gpt', 'response') }}
+```
+
+### 💡 Naming Rules
+- Prefix is always `sensor.ha_text_ai_`
+- Add your unique identifier after the underscore
+- Use lowercase
+- No spaces allowed
+- Keep it descriptive but concise
+
+### 🔍 HA Text AI Sensor Attributes
+
+#### Model and Provider Information
+```yaml
+# Name of the AI model currently in use (e.g., latest version of GPT)  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Model') }}           # gpt-4o  
+
+# Service provider for the AI model (determines API endpoint and authentication)  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Api provider') }}    # openai  
+
+# Previous or alternative model configuration  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Last model') }}      # gpt-4o
+```
+
+#### System Status
+```yaml
+# Current operational readiness of the AI service API  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Api status') }}      # ready  
+
+# Indicates if a request is currently being processed  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Is processing') }}   # false  
+
+# Shows if the API has hit its request rate limit  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Is rate limited') }} # false  
+
+# Status of the specific API endpoint being used  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Endpoint status') }} # ready
+```
+
+#### Performance Metrics
+```yaml
+# Total number of successfully completed API requests  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Successful requests') }}   # 0  
+
+# Number of API requests that encountered errors  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Failed requests') }}       # 0  
+
+# Mean time taken to receive a response from the AI service  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Average latency') }}       # 0  
+
+# Maximum time taken for a single request-response cycle  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Max latency') }}           # 0
+```
+
+#### Conversation and Token Usage
+```yaml
+# Number of previous interactions stored in conversation context  
+{{ state_attr('sensor.ha_text_ai_gpt', 'History size') }}          # 0  
+
+# Total number of tokens used across all interactions  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Total tokens') }}          # 0  
+
+# Tokens used in the input prompts  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Prompt tokens') }}         # 0  
+
+# Tokens used in the AI's generated responses  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Completion tokens') }}     # 0
+```
+
+#### Last Interaction Details
+```yaml
+# Most recent complete response generated by the AI service  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Response') }}        # Last AI response  
+
+# The most recently processed user query or prompt  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Question') }}        # Last asked question  
+
+# Precise moment when the last interaction occurred (useful for tracking and logging)  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Last timestamp') }}  # Timestamp
+```
+
+#### System Health
+```yaml
+# Cumulative count of all errors encountered during AI service interactions  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Total errors') }}    # 0  
+
+# Indicates if the AI service is currently undergoing scheduled or emergency maintenance  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Is maintenance') }}  # false  
+
+# Total continuous operational time of the AI service (in hours or days)  
+{{ state_attr('sensor.ha_text_ai_gpt', 'Uptime') }}          # 547,58
+```
+
+### 💡 Pro Tips
+- Always check attribute existence
+- Use these attributes for monitoring and automation
+- Some values might be 0 or empty initially
+
+
 ## 📘 FAQ
 
 **Q: Which AI providers are supported?**
@@ -228,15 +412,45 @@ Contributions welcome! Please read our [Contributing Guide](CONTRIBUTING.md).
 4. Push branch (`git push origin feature/Enhancement`)
 5. Open Pull Request
 
+## Legal Disclaimer and Limitation of Liability  
+
+### Software Disclaimer  
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,   
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A   
+PARTICULAR PURPOSE AND NONINFRINGEMENT.  
+
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,   
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER   
+DEALINGS IN THE SOFTWARE.  
+
 ## 📝 License
 
-MIT License - see [LICENSE](LICENSE) for details.
+Author: SMKRV
+[CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) - see [LICENSE](LICENSE) for details. 
+
+## 💡 Support the Project
+
+The best support is:
+- Sharing feedback
+- Contributing ideas
+- Recommending to friends
+- Reporting issues
+- Star the repository
+
+If you want to say thanks financially, you can send a small token of appreciation in USDT:
+
+**USDT Wallet (TRC10/TRC20):**
+`TXC9zYHYPfWUGi4Sv4R1ctTBGScXXQk5HZ`
+
+*Open-source is built by community passion!* 🚀
 
 ---
 
 <div align="center">
 
-Made with ❤️ for the Home Assistant Community
+Made with ❤️ and Claude 3.5 Sonnet for the Home Assistant Community
 
 [Report Bug](https://github.com/smkrv/ha-text-ai/issues) · [Request Feature](https://github.com/smkrv/ha-text-ai/issues)
 

custom_components/ha_text_ai/__init__.py

@@ -1,4 +1,11 @@
-"""The HA Text AI integration."""
+"""
+The HA Text AI integration.
+
+@license: CC BY-NC-SA 4.0 International
+@author: SMKRV
+@github: https://github.com/smkrv/ha-text-ai
+@source: https://github.com/smkrv/ha-text-ai
+"""
 from __future__ import annotations
 
 import logging
@@ -43,6 +50,8 @@ from .const import (
     SERVICE_CLEAR_HISTORY,
     SERVICE_GET_HISTORY,
     SERVICE_SET_SYSTEM_PROMPT,
+    DEFAULT_MAX_HISTORY,
+    CONF_MAX_HISTORY_SIZE,
 )
 
 _LOGGER = logging.getLogger(__name__)
@@ -89,7 +98,7 @@ async def async_setup(hass: HomeAssistant, config: Dict[str, Any]) -> bool:
         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.svg')
+        dest = os.path.join(dest_dir, 'icon.png')
         if not os.path.exists(dest):
             shutil.copyfile(source, dest)
     except Exception as ex:
@@ -197,11 +206,14 @@ async def async_check_api(session, endpoint: str, headers: dict, provider: str)
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up HA Text AI from a config entry."""
+    _LOGGER.debug(f"Setting up HA Text AI entry: {entry.data}")
+
     try:
         if CONF_API_PROVIDER not in entry.data:
             _LOGGER.error("API provider not specified")
             raise ConfigEntryNotReady("API provider is required")
 
+        # Get configuration
         session = aiohttp_client.async_get_clientsession(hass)
         api_provider = entry.data.get(CONF_API_PROVIDER)
         model = entry.data.get(CONF_MODEL, DEFAULT_MODEL)
@@ -212,6 +224,11 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
         ).rstrip('/')
         api_key = entry.data[CONF_API_KEY]
         instance_name = entry.data.get(CONF_NAME, entry.entry_id)
+        request_interval = entry.data.get(CONF_REQUEST_INTERVAL, DEFAULT_REQUEST_INTERVAL)
+        max_tokens = entry.data.get(CONF_MAX_TOKENS, DEFAULT_MAX_TOKENS)
+        temperature = entry.data.get(CONF_TEMPERATURE, DEFAULT_TEMPERATURE)
+        max_history_size = entry.data.get(CONF_MAX_HISTORY_SIZE, DEFAULT_MAX_HISTORY)
+        context_messages = entry.data.get(CONF_CONTEXT_MESSAGES, DEFAULT_CONTEXT_MESSAGES)
         is_anthropic = api_provider == API_PROVIDER_ANTHROPIC
 
         headers = {
@@ -242,39 +259,33 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
             hass=hass,
             client=api_client,
             model=model,
-            update_interval=entry.data.get(CONF_REQUEST_INTERVAL, DEFAULT_REQUEST_INTERVAL),
+            update_interval=request_interval,
             instance_name=instance_name,
-            max_tokens=entry.data.get(CONF_MAX_TOKENS, DEFAULT_MAX_TOKENS),
-            temperature=entry.data.get(CONF_TEMPERATURE, DEFAULT_TEMPERATURE),
+            max_tokens=max_tokens,
+            temperature=temperature,
+            max_history_size=max_history_size,
+            context_messages=context_messages,
             is_anthropic=is_anthropic,
-            context_messages=entry.data.get(
-                CONF_CONTEXT_MESSAGES,
-                DEFAULT_CONTEXT_MESSAGES
-            ),
         )
 
-        coordinator.data = coordinator._initial_state.copy()
-        _LOGGER.debug(f"Initial state set for coordinator {instance_name}")
-
-        await coordinator.async_config_entry_first_refresh()
+        _LOGGER.debug(f"Created coordinator for {instance_name}")
 
+        # Store coordinator
         hass.data.setdefault(DOMAIN, {})
         hass.data[DOMAIN][entry.entry_id] = coordinator
 
+        _LOGGER.debug(f"Stored coordinator in hass.data[{DOMAIN}][{entry.entry_id}]")
+
+        # Set up platforms
         await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
-        _LOGGER.info(
-            "Successfully set up %s instance '%s' with model %s",
-            api_provider,
-            instance_name,
-            model
-        )
+        _LOGGER.debug(f"Setup completed for {instance_name}")
 
         return True
 
-    except Exception as ex:
-        _LOGGER.exception("Setup error: %s", str(ex))
-        raise ConfigEntryNotReady(f"Setup error: {str(ex)}") from ex
+    except Exception as err:
+        _LOGGER.exception(f"Error setting up HA Text AI: {err}")
+        raise
 
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""

custom_components/ha_text_ai/api_client.py

@@ -1,4 +1,11 @@
-"""API Client for HA Text AI."""
+"""
+API Client for HA Text AI.
+
+@license: CC BY-NC-SA 4.0 International
+@author: SMKRV
+@github: https://github.com/smkrv/ha-text-ai
+@source: https://github.com/smkrv/ha-text-ai
+"""
 import logging
 import asyncio
 from typing import Any, Dict, List, Optional
@@ -19,6 +26,7 @@ from .const import (
 
 _LOGGER = logging.getLogger(__name__)
 
+
 class APIClient:
     """API Client for OpenAI and Anthropic."""
 
@@ -59,6 +67,7 @@ class APIClient:
         payload: Dict[str, Any],
     ) -> Dict[str, Any]:
         """Make API request with retry logic."""
+        _LOGGER.debug(f"API Request: URL={url}, Payload={payload}")
         for attempt in range(API_RETRY_COUNT):
             try:
                 async with timeout(API_TIMEOUT):
@@ -66,20 +75,23 @@ class APIClient:
                         url,
                         json=payload,
                         headers=self.headers,
-                        timeout=self.timeout
+                        timeout=self.timeout,
                     ) as response:
+                        _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}")
                         return await response.json()
             except asyncio.TimeoutError:
+                _LOGGER.warning(f"Timeout on attempt {attempt + 1}")
                 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)}")
                 if attempt == API_RETRY_COUNT - 1:
                     raise
-                _LOGGER.warning("API request failed, retrying: %s", str(e))
                 await asyncio.sleep(1 * (attempt + 1))
 
     async def create(
@@ -101,6 +113,11 @@ class APIClient:
                 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)}")
@@ -125,16 +142,14 @@ class APIClient:
         return {
             "choices": [
                 {
-                    "message": {
-                        "content": data["choices"][0]["message"]["content"]
-                    }
+                    "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"]
-            }
+                "total_tokens": data["usage"]["total_tokens"],
+            },
         }
 
     async def _create_anthropic_completion(
@@ -147,19 +162,24 @@ class APIClient:
         """Create completion using Anthropic API."""
         url = f"{self.endpoint}/v1/messages"
 
-        # Convert messages to Anthropic format
-        system_prompt = next(
-            (msg["content"] for msg in messages if msg["role"] == "system"),
-            None
-        )
-        conversation = [msg for msg in messages if msg["role"] != "system"]
+        system_prompt = None
+        filtered_messages = []
+        for msg in messages:
+            if msg['role'] == 'system':
+                if system_prompt is None:
+                    system_prompt = msg['content']
+                else:
+                    system_prompt += f" {msg['content']}"
+            else:
+                filtered_messages.append(msg)
 
         payload = {
             "model": model,
-            "messages": conversation,
+            "messages": filtered_messages,
             "max_tokens": max_tokens,
             "temperature": temperature,
         }
+
         if system_prompt:
             payload["system"] = system_prompt
 
@@ -167,14 +187,26 @@ class APIClient:
         return {
             "choices": [
                 {
-                    "message": {
-                        "content": data["content"][0]["text"]
-                    }
+                    "message": {"content": data["content"][0]["text"]},
                 }
             ],
             "usage": {
                 "prompt_tokens": data["usage"]["input_tokens"],
                 "completion_tokens": data["usage"]["output_tokens"],
-                "total_tokens": data["usage"]["input_tokens"] + data["usage"]["output_tokens"]
-            }
+                "total_tokens": data["usage"]["input_tokens"] + data["usage"]["output_tokens"],
+            },
         }
+
+    async def check_connection(self) -> bool:
+        """Check API connection."""
+        try:
+            await self._make_request(self.endpoint, {"test": "connection"})
+            return True
+        except Exception as e:
+            _LOGGER.error(f"Connection check failed: {str(e)}")
+            return False
+
+    async def shutdown(self) -> None:
+        """Shutdown API client."""
+        _LOGGER.debug("Shutting down API client")
+        await self.session.close()

custom_components/ha_text_ai/config_flow.py

@@ -1,4 +1,11 @@
-"""Config flow for HA text AI integration."""
+"""
+Config flow for HA text AI integration.
+
+@license: CC BY-NC-SA 4.0 International
+@author: SMKRV
+@github: https://github.com/smkrv/ha-text-ai
+@source: https://github.com/smkrv/ha-text-ai
+"""
 import logging
 from typing import Any, Dict, Optional
 
@@ -34,10 +41,21 @@ from .const import (
     MIN_MAX_TOKENS,
     MAX_MAX_TOKENS,
     MIN_REQUEST_INTERVAL,
+    DEFAULT_NAME_PREFIX,
+    DEFAULT_MAX_HISTORY,
+    CONF_MAX_HISTORY_SIZE,
 )
 
 _LOGGER = logging.getLogger(__name__)
 
+
+def normalize_name(name: str) -> str:
+    """Normalize name to conform to HA naming convention using underscores."""
+    normalized = ''.join(c if c.isalnum() or c == '_' else '_' for c in name)
+    normalized = '_'.join(filter(None, normalized.split('_')))
+    return normalized.lower()
+
+
 class HATextAIConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow for HA text AI."""
 
@@ -69,18 +87,18 @@ class HATextAIConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
 
     async def async_step_provider(self, user_input: Optional[Dict[str, Any]] = None) -> FlowResult:
         """Handle provider configuration step."""
+        self._errors = {}
+
         if user_input is None:
             default_endpoint = (
                 DEFAULT_OPENAI_ENDPOINT if self._provider == API_PROVIDER_OPENAI
                 else DEFAULT_ANTHROPIC_ENDPOINT
             )
 
-            suggested_name = f"HA Text AI {len(self._async_current_entries()) + 1}"
-
             return self.async_show_form(
                 step_id="provider",
                 data_schema=vol.Schema({
-                    vol.Required(CONF_NAME, default=suggested_name): str,
+                    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_API_ENDPOINT, default=default_endpoint): str,
@@ -103,27 +121,86 @@ class HATextAIConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
                         vol.Coerce(int),
                         vol.Range(min=1, max=20)
                     ),
-                }),
-                errors=self._errors
+                    vol.Optional(
+                        CONF_MAX_HISTORY_SIZE,
+                        default=DEFAULT_MAX_HISTORY
+                    ): vol.All(
+                        vol.Coerce(int),
+                        vol.Range(min=1, max=100)
+                    ),
+                })
             )
 
-        instance_name = user_input[CONF_NAME]
-        await self._async_validate_name(instance_name)
-        if self._errors:
-            return await self.async_step_provider()
+        input_copy = user_input.copy()
 
-        if not await self._async_validate_api(user_input):
-            return await self.async_step_provider()
+        try:
+            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.Optional(CONF_TEMPERATURE, default=input_copy.get(CONF_TEMPERATURE, DEFAULT_TEMPERATURE)): vol.All(
+                        vol.Coerce(float),
+                        vol.Range(min=MIN_TEMPERATURE, max=MAX_TEMPERATURE)
+                    ),
+                }),
+                errors={"name": str(e)}
+            )
 
-        return await self._create_entry(user_input)
+        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
+                )
+        except Exception as e:
+            return self.async_show_form(
+                step_id="provider",
+                data_schema=vol.Schema({
+                }),
+                errors={"base": str(e)}
+            )
+
+        return await self._create_entry(input_copy)
+
+    def _validate_and_normalize_name(self, name: str) -> str:
+        """
+        Validate and normalize name with detailed error handling.
+
+        Raises:
+            ValueError: If name is invalid
+
+        Returns:
+            Normalized name
+        """
+        if not name:
+            raise ValueError("empty")
+
+        name = name.strip()
+        normalized = ''.join(
+            c if c.isalnum() or c in ' _' else '_'  # Only allow underscores
+            for c in name
+        )
+
+        normalized = normalized.replace(' ', '_').lower()
 
-    async def _async_validate_name(self, name: str) -> bool:
-        """Validate that the name is unique."""
         for entry in self._async_current_entries():
-            if entry.data.get(CONF_NAME) == name:
-                self._errors["name"] = "name_exists"
-                return False
-        return True
+            if entry.data.get(CONF_NAME, "") == normalized:
+                raise ValueError("name_exists")
+
+        normalized = normalized[:50]
+
+        if not normalized:
+            raise ValueError("empty")
+
+        return normalized
 
     async def _async_validate_api(self, user_input: Dict[str, Any]) -> bool:
         """Validate API connection."""
@@ -167,21 +244,36 @@ class HATextAIConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
         }
 
     async def _create_entry(self, user_input: Dict[str, Any]) -> FlowResult:
-        """Create the config entry."""
+        """Create the config entry with comprehensive data preservation."""
         instance_name = user_input[CONF_NAME]
-        unique_id = f"{DOMAIN}_{instance_name}_{self._provider}".lower().replace(" ", "_")
+        normalized_name = normalize_name(instance_name)
+
+        unique_id = f"{DOMAIN}_{normalized_name}_{self._provider}".lower()
+
+        entry_data = {
+            CONF_API_PROVIDER: self._provider,
+            CONF_NAME: instance_name,
+            "normalized_name": normalized_name,
+            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_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),
+            CONF_CONTEXT_MESSAGES: user_input.get(CONF_CONTEXT_MESSAGES, DEFAULT_CONTEXT_MESSAGES),
+            CONF_MAX_HISTORY_SIZE: user_input.get(CONF_MAX_HISTORY_SIZE, DEFAULT_MAX_HISTORY),
+        }
+
+        for key, value in user_input.items():
+            if key not in entry_data:
+                entry_data[key] = value
+
+        _LOGGER.debug(f"Creating config entry with data: {entry_data}")
 
         return self.async_create_entry(
             title=instance_name,
-            data={
-                CONF_API_PROVIDER: self._provider,
-                CONF_NAME: instance_name,
-                **user_input,
-                "unique_id": unique_id,
-                CONF_CONTEXT_MESSAGES: user_input.get(
-                CONF_CONTEXT_MESSAGES,
-                DEFAULT_CONTEXT_MESSAGES)
-        }
+            data=entry_data
         )
 
     @staticmethod
@@ -243,5 +335,15 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
                     vol.Coerce(int),
                     vol.Range(min=1, max=20)
                 ),
+                vol.Optional(
+                    CONF_MAX_HISTORY_SIZE,
+                    default=current_data.get(
+                        CONF_MAX_HISTORY_SIZE,
+                        DEFAULT_MAX_HISTORY
+                    )
+                ): vol.All(
+                    vol.Coerce(int),
+                    vol.Range(min=1, max=100)
+                ),
             })
         )

custom_components/ha_text_ai/const.py

@@ -1,4 +1,11 @@
-"""Constants for the HA text AI integration."""
+"""
+Constants for the HA text AI integration.
+
+@license: CC BY-NC-SA 4.0 International
+@author: SMKRV
+@github: https://github.com/smkrv/ha-text-ai
+@source: https://github.com/smkrv/ha-text-ai
+"""
 from typing import Final
 import voluptuous as vol
 from homeassistant.const import Platform, CONF_API_KEY, CONF_NAME
@@ -6,7 +13,7 @@ from homeassistant.helpers import config_validation as cv
 
 # Domain and platforms
 DOMAIN: Final = "ha_text_ai"
-PLATFORMS: Final = [Platform.SENSOR]
+PLATFORMS: list[str] = ["sensor"]
 
 # Provider configuration
 CONF_API_PROVIDER: Final = "api_provider"
@@ -29,7 +36,7 @@ CONF_MAX_TOKENS: Final = "max_tokens"
 CONF_API_ENDPOINT: Final = "api_endpoint"
 CONF_REQUEST_INTERVAL: Final = "request_interval"
 CONF_INSTANCE: Final = "instance"
-CONF_MAX_HISTORY_SIZE: Final = "max_history_size"
+CONF_MAX_HISTORY_SIZE: Final = "max_history_size"  # Correct constant name
 CONF_IS_ANTHROPIC: Final = "is_anthropic"
 CONF_CONTEXT_MESSAGES: Final = "context_messages"
 
@@ -41,6 +48,7 @@ DEFAULT_REQUEST_INTERVAL: Final = 1.0
 DEFAULT_TIMEOUT: Final = 30
 DEFAULT_MAX_HISTORY: Final = 50
 DEFAULT_NAME: Final = "HA Text AI"
+DEFAULT_NAME_PREFIX = "ha_text_ai"
 DEFAULT_CONTEXT_MESSAGES: Final = 5
 
 # Parameter constraints
@@ -164,7 +172,7 @@ SERVICE_SCHEMA_GET_HISTORY = vol.Schema({
     vol.Required(CONF_INSTANCE): cv.string,
     vol.Optional("limit", default=10): vol.All(
         vol.Coerce(int),
-        vol.Range(min=1, max=100)
+        vol.Range(min=1, max=100),
     ),
     vol.Optional("filter_model"): cv.string
 })
@@ -189,7 +197,7 @@ CONFIG_SCHEMA = vol.Schema({
             vol.Coerce(float),
             vol.Range(min=MIN_REQUEST_INTERVAL, max=MAX_REQUEST_INTERVAL)
         ),
-        vol.Optional(CONF_MAX_HISTORY_SIZE, default=DEFAULT_MAX_HISTORY): vol.All(
+        vol.Optional(CONF_MAX_HISTORY_SIZE, default=DEFAULT_MAX_HISTORY): vol.All(  # Correct usage
             vol.Coerce(int),
             vol.Range(min=1, max=100),
         ),

custom_components/ha_text_ai/coordinator.py

@@ -1,7 +1,15 @@
-"""The HA Text AI coordinator."""
+"""
+The HA Text AI coordinator.
+
+@license: CC BY-NC-SA 4.0 International
+@author: SMKRV
+@github: https://github.com/smkrv/ha-text-ai
+@source: https://github.com/smkrv/ha-text-ai
+"""
 from __future__ import annotations
 
 import logging
+import traceback
 from datetime import datetime, timedelta
 from typing import Any, Dict, List, Optional
 
@@ -9,6 +17,8 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from homeassistant.util import dt as dt_util
 from homeassistant.exceptions import HomeAssistantError
+from homeassistant.const import CONF_NAME
+from .config_flow import normalize_name
 
 from .const import (
     DOMAIN,
@@ -21,11 +31,16 @@ from .const import (
     DEFAULT_TEMPERATURE,
     DEFAULT_MAX_HISTORY,
     DEFAULT_CONTEXT_MESSAGES,
+    DEFAULT_NAME_PREFIX,
+    CONF_MAX_HISTORY_SIZE,
 )
 
 _LOGGER = logging.getLogger(__name__)
 
+
 class HATextAICoordinator(DataUpdateCoordinator):
+    """The HA Text AI coordinator."""
+
     def __init__(
         self,
         hass: HomeAssistant,
@@ -41,6 +56,12 @@ class HATextAICoordinator(DataUpdateCoordinator):
     ) -> None:
         """Initialize coordinator."""
         self.instance_name = instance_name
+        self.normalized_name = None
+
+        # Use the normalize_name function from config_flow to ensure consistency
+        from .config_flow import normalize_name
+        self.normalized_name = normalize_name(instance_name)
+
         self.hass = hass
         self.client = client
         self.model = model
@@ -61,7 +82,7 @@ class HATextAICoordinator(DataUpdateCoordinator):
                 "total_errors": 0,
                 "average_latency": 0,
                 "max_latency": 0,
-                "min_latency": float('inf'),
+                "min_latency": float("inf"),
             },
             "last_response": {
                 "timestamp": dt_util.utcnow().isoformat(),
@@ -69,7 +90,8 @@ class HATextAICoordinator(DataUpdateCoordinator):
                 "response": "",
                 "model": model,
                 "instance": instance_name,
-                "error": None
+                "normalized_name": self.normalized_name,
+                "error": None,
             },
             "is_processing": False,
             "is_rate_limited": False,
@@ -105,13 +127,17 @@ class HATextAICoordinator(DataUpdateCoordinator):
         self.last_response = self._initial_state["last_response"].copy()
         self._start_time = dt_util.utcnow()
 
-        _LOGGER.info(f"Initialized HA Text AI coordinator with instance: {instance_name}")
+        _LOGGER.info(
+            f"Initialized HA Text AI coordinator with instance: {instance_name}"
+        )
 
     async def _async_update_data(self) -> Dict[str, Any]:
         """Update data via library."""
         try:
             current_state = self._get_current_state()
-            _LOGGER.debug(f"Updating data for {self.instance_name}, current state: {current_state}")
+            _LOGGER.debug(
+                f"Updating data for {self.instance_name}, current state: {current_state}"
+            )
 
             data = {
                 "state": current_state,
@@ -125,6 +151,7 @@ class HATextAICoordinator(DataUpdateCoordinator):
                 "system_prompt": self._system_prompt,
                 "history_size": len(self._conversation_history),
                 "conversation_history": self._conversation_history,
+                "normalized_name": self.normalized_name,
             }
 
             # Validate data
@@ -141,12 +168,15 @@ class HATextAICoordinator(DataUpdateCoordinator):
     async def async_update_ha_state(self) -> None:
         """Update Home Assistant state."""
         try:
-            _LOGGER.debug(f"Requesting state update for {self.instance_name}")
+            _LOGGER.debug(
+                f"Requesting state update for {self.instance_name} (normalized: {self.normalized_name})"
+            )
             await self.async_request_refresh()
 
             # Force update of all entities
+            entity_id_base = f"sensor.ha_text_ai_{self.normalized_name.lower()}"
             for entity_id in self.hass.states.async_entity_ids():
-                if entity_id.startswith(f"sensor.ha_text_ai_{self.instance_name}"):
+                if entity_id.startswith(entity_id_base):
                     self.hass.states.async_set(entity_id, self._get_current_state())
 
         except Exception as err:
@@ -164,15 +194,67 @@ class HATextAICoordinator(DataUpdateCoordinator):
             return STATE_ERROR
         return STATE_READY
 
-    def _calculate_context_tokens(self, messages: List[Dict[str, str]]) -> int:
+    def _calculate_context_tokens(self, messages: List[Dict[str, str]], model: str = None) -> int:
+        """
+        Estimate tokens for conversation context.
+
+        Args:
+            messages: List of message dictionaries
+            model: Optional model name for provider-specific estimation
+
+        Returns:
+            Estimated number of tokens
+        """
         try:
+            # Anthropic specific token counting
             if self.is_anthropic and hasattr(self.client, 'count_tokens'):
                 return sum(self.client.count_tokens(msg['content']) for msg in messages)
 
-            return sum(len(msg['content']) // 4 for msg in messages)
+            def estimate_tokens(text: str) -> int:
+                """
+                Flexible token estimation algorithm.
+
+                Heuristics:
+                - Count words
+                - Estimate special characters
+                - Fallback to character-based estimation
+                """
+                # Word-based estimation
+                words = len(text.split())
+
+                # Special character handling
+                special_chars = sum(1 for char in text if not char.isalnum())
+
+                # Character-based fallback
+                char_tokens = len(text) // 4
+
+                # Combine estimations with bias towards words
+                total_tokens = (words * 1.5) + (special_chars * 0.5) + char_tokens
+
+                return max(int(total_tokens), words)
+
+            # Calculate total tokens across all messages
+            total_tokens = sum(estimate_tokens(msg['content']) for msg in messages)
+
+            # Logging for debugging
+            _LOGGER.debug(
+                f"Token Estimation: "
+                f"Messages: {len(messages)}, "
+                f"Estimated Tokens: {total_tokens}"
+            )
+
+            return total_tokens
+
         except Exception as e:
-            _LOGGER.warning(f"Error calculating context tokens: {e}")
-        return 0
+            # Safe fallback with detailed logging
+            _LOGGER.warning(
+                f"Token estimation failed. "
+                f"Error: {e}. "
+                f"Using conservative estimation."
+            )
+
+            # Conservative token estimation
+            return len(messages) * 100
 
     async def async_ask_question(
         self,
@@ -183,80 +265,133 @@ class HATextAICoordinator(DataUpdateCoordinator):
         system_prompt: Optional[str] = None,
         context_messages: Optional[int] = None,
     ) -> dict:
-        """Process a question with optional parameters."""
+        """
+        Process a question with optional parameters.
+
+        This method is a direct wrapper around async_process_question,
+        allowing flexible AI interaction with optional model, temperature,
+        and context customization.
+
+        Args:
+            question: The input question or prompt
+            model: Optional AI model to use
+            temperature: Optional response creativity level
+            max_tokens: Optional maximum response length
+            system_prompt: Optional system-level instruction
+            context_messages: Optional number of context messages to include
+
+        Returns:
+            Full response dictionary from the AI
+        """
         return await self.async_process_question(
             question, model, temperature, max_tokens, system_prompt, context_messages
         )
 
     async def async_process_question(
-        self,
-        question: str,
-        model: Optional[str] = None,
-        temperature: Optional[float] = None,
-        max_tokens: Optional[int] = None,
-        system_prompt: Optional[str] = None,
-        context_messages: Optional[int] = None,
-    ) -> dict:
-        temp_context_messages = context_messages or self.context_messages
+            self,
+            question: str,
+            model: Optional[str] = None,
+            temperature: Optional[float] = None,
+            max_tokens: Optional[int] = None,
+            system_prompt: Optional[str] = None,
+            context_messages: Optional[int] = None,
+        ) -> dict:
+            """
+            Enhanced question processing with intelligent token management.
+            """
+            try:
+                self._is_processing = True
+                await self.async_update_ha_state()
 
-        if not question:
-            raise ValueError("Question cannot be empty")
+                temp_context_messages = context_messages or self.context_messages
+                temp_model = model or self.model
+                temp_temperature = temperature or self.temperature
+                temp_max_tokens = max_tokens or self.max_tokens
+                temp_system_prompt = system_prompt or self._system_prompt
 
-        _LOGGER.debug(f"Processing question for instance {self.instance_name}")
+                # Start timing
+                start_time = dt_util.utcnow()
 
-        try:
-            self._is_processing = True
-            await self.async_update_ha_state()
-
-            temp_model = model or self.model
-            temp_temperature = temperature or self.temperature
-            temp_max_tokens = max_tokens or self.max_tokens
-            temp_system_prompt = system_prompt or self._system_prompt
-
-            start_time = dt_util.utcnow()
-
-            messages = []
-            if temp_system_prompt:
-                if self.is_anthropic:
-                    system_content = f"\n\nHuman: {temp_system_prompt}\n\nAssistant: I understand and will follow these instructions."
-                    messages.append({"role": "user", "content": system_content})
-                else:
+                # Prepare messages with system prompt
+                messages = []
+                if temp_system_prompt:
                     messages.append({"role": "system", "content": temp_system_prompt})
 
-            # Add conversation history
-            context_history = self._conversation_history[-temp_context_messages:]
-            for entry in context_history:
-                messages.append({"role": "user", "content": entry["question"]})
-                messages.append({"role": "assistant", "content": entry["response"]})
+                # Context history management
+                context_history = self._conversation_history[-temp_context_messages:]
 
-            messages.append({"role": "user", "content": question})
+                # Comprehensive token calculation
+                context_tokens = self._calculate_context_tokens(
+                    [{"content": entry["question"]} for entry in context_history] +
+                    [{"content": entry["response"]} for entry in context_history] +
+                    [{"content": question}],
+                    temp_model
+                )
 
-            kwargs = {
-                "model": temp_model,
-                "temperature": temp_temperature,
-                "max_tokens": temp_max_tokens,
-                "messages": messages,
-            }
+                # Dynamic token allocation
+                available_tokens = max(0, temp_max_tokens - context_tokens)
 
-            response = await self.async_process_message(question, **kwargs)
+                # Context trimming if over token limit
+                if context_tokens > temp_max_tokens:
+                    _LOGGER.warning(
+                        f"Token limit exceeded. "
+                        f"Context: {context_tokens}, "
+                        f"Max: {temp_max_tokens}"
+                    )
 
-            # Update metrics
-            end_time = dt_util.utcnow()
-            latency = (end_time - start_time).total_seconds()
-            self._update_metrics(latency, response)
+                    # Intelligent context reduction
+                    while context_tokens > temp_max_tokens // 2 and context_history:
+                        context_history.pop(0)
+                        context_tokens = self._calculate_context_tokens(
+                            [{"content": entry["question"]} for entry in context_history] +
+                            [{"content": entry["response"]} for entry in context_history] +
+                            [{"content": question}],
+                            temp_model
+                        )
 
-            # Update history
-            self._update_history(question, response)
+                # Rebuild messages with trimmed context
+                for entry in context_history:
+                    messages.append({"role": "user", "content": entry["question"]})
+                    messages.append({"role": "assistant", "content": entry["response"]})
 
-            return response
+                messages.append({"role": "user", "content": question})
 
-        except Exception as err:
-            self._handle_error(err)
-            raise HomeAssistantError(f"Failed to process question: {err}")
+                # Detailed token logging
+                _LOGGER.debug(
+                    f"Token Analysis: "
+                    f"Context Tokens: {context_tokens}, "
+                    f"Max Tokens: {temp_max_tokens}, "
+                    f"Available Tokens: {available_tokens}"
+                )
 
-        finally:
-            self._is_processing = False
-            await self.async_update_ha_state()
+                # Prepare API call with dynamic token management
+                kwargs = {
+                    "model": temp_model,
+                    "temperature": temp_temperature,
+                    "max_tokens": min(temp_max_tokens, available_tokens),
+                    "messages": messages,
+                }
+
+                # Process message
+                response = await self.async_process_message(question, **kwargs)
+
+                # Update metrics
+                end_time = dt_util.utcnow()
+                latency = (end_time - start_time).total_seconds()
+                self._update_metrics(latency, response)
+
+                # Update history
+                self._update_history(question, response)
+
+                return response
+
+            except Exception as err:
+                self._handle_error(err)
+                raise HomeAssistantError(f"Failed to process question: {err}")
+
+            finally:
+                self._is_processing = False
+                await self.async_update_ha_state()
 
     async def async_process_message(self, question: str, **kwargs) -> dict:
         """Process message using the AI client."""
@@ -272,7 +407,7 @@ class HATextAICoordinator(DataUpdateCoordinator):
                 "response": response["content"],
                 "model": kwargs.get("model", self.model),
                 "instance": self.instance_name,
-                "error": None
+                "error": None,
             }
 
             return response
@@ -283,20 +418,26 @@ class HATextAICoordinator(DataUpdateCoordinator):
 
     async def _process_anthropic_message(self, question: str, **kwargs) -> dict:
         """Process message using Anthropic API."""
-        response = await self.client.messages.create(
-            model=kwargs["model"],
-            max_tokens=kwargs["max_tokens"],
-            messages=kwargs["messages"],
-            temperature=kwargs["temperature"],
-        )
-        return {
-            "content": response.content[0].text,
-            "tokens": {
-                "prompt": response.usage.input_tokens,
-                "completion": response.usage.output_tokens,
-                "total": response.usage.input_tokens + response.usage.output_tokens
+        try:
+            _LOGGER.debug(f"Anthropic API call: model={kwargs['model']}, max_tokens={kwargs['max_tokens']}")
+            response = await self.client.messages.create(
+                model=kwargs["model"],
+                max_tokens=kwargs["max_tokens"],
+                messages=kwargs["messages"],
+                temperature=kwargs["temperature"],
+            )
+            _LOGGER.debug(f"Anthropic response: tokens={response.usage}")
+            return {
+                "content": response.content[0].text,
+                "tokens": {
+                    "prompt": response.usage.input_tokens,
+                    "completion": response.usage.output_tokens,
+                    "total": response.usage.input_tokens + response.usage.output_tokens,
+                },
             }
-        }
+        except Exception as e:
+            _LOGGER.error(f"Anthropic API error: {str(e)}")
+            raise
 
     async def _process_openai_message(self, question: str, **kwargs) -> dict:
         """Process message using OpenAI API."""
@@ -313,8 +454,8 @@ class HATextAICoordinator(DataUpdateCoordinator):
                 "tokens": {
                     "prompt": response["usage"]["prompt_tokens"],
                     "completion": response["usage"]["completion_tokens"],
-                    "total": response["usage"]["total_tokens"]
-                }
+                    "total": response["usage"]["total_tokens"],
+                },
             }
         except Exception as e:
             _LOGGER.error(f"Error in OpenAI API call: {str(e)}")
@@ -339,29 +480,68 @@ class HATextAICoordinator(DataUpdateCoordinator):
 
     def _update_history(self, question: str, response: dict) -> None:
         """Update conversation history."""
-        self._conversation_history.append({
-            "timestamp": dt_util.utcnow().isoformat(),
-            "question": question,
-            "response": response["content"]
-        })
+        self._conversation_history.append(
+            {
+                "timestamp": dt_util.utcnow().isoformat(),
+                "question": question,
+                "response": response["content"],
+            }
+        )
 
         while len(self._conversation_history) > self.max_history_size:
             self._conversation_history.pop(0)
 
     def _handle_error(self, error: Exception) -> None:
-        """Handle error and update metrics."""
+        """
+        Enhanced error handling with comprehensive diagnostics.
+
+        Captures detailed error information, tracks error metrics,
+        and provides context for troubleshooting AI processing issues.
+        """
         self._performance_metrics["total_errors"] += 1
         self._performance_metrics["failed_requests"] += 1
 
-        self.last_response = {
+        error_details = {
             "timestamp": dt_util.utcnow().isoformat(),
-            "question": "",
-            "response": "",
             "model": self.model,
             "instance": self.instance_name,
-            "error": str(error)
+            "error_message": str(error),
+            "error_type": type(error).__name__,
+            "traceback": traceback.format_exc() if _LOGGER.isEnabledFor(logging.DEBUG) else None,
         }
 
+        # Specific error type handling
+        error_mapping = {
+            HomeAssistantError: {"is_ha_error": True},
+            ConnectionError: {
+                "is_connection_error": True,
+                "is_rate_limited": True
+            },
+            TimeoutError: {"is_timeout": True},
+            PermissionError: {"is_permission_denied": True},
+            ValueError: {"is_validation_error": True}
+        }
+
+        for error_type, error_flags in error_mapping.items():
+            if isinstance(error, error_type):
+                error_details.update(error_flags)
+                break
+
+        # Update system state based on error type
+        if error_details.get("is_rate_limited"):
+            self._is_rate_limited = True
+            _LOGGER.warning(f"Rate limit detected for {self.instance_name}")
+
+        if error_details.get("is_connection_error"):
+            self.endpoint_status = "unavailable"
+
+        self.last_response = error_details
+        _LOGGER.error(f"AI Processing Error: {error_details}")
+
+        # Optional: Add more sophisticated error tracking or notification logic
+        if _LOGGER.isEnabledFor(logging.DEBUG):
+            _LOGGER.debug(f"Full Error Traceback: {error_details['traceback']}")
+
     async def async_clear_history(self) -> None:
         """Clear conversation history."""
         self._conversation_history = []
@@ -375,3 +555,8 @@ class HATextAICoordinator(DataUpdateCoordinator):
         """Set system prompt."""
         self._system_prompt = prompt
         await self.async_update_ha_state()
+
+    async def async_shutdown(self) -> None:
+        """Shutdown coordinator."""
+        _LOGGER.debug(f"Shutting down coordinator for {self.instance_name}")
+        self.hass.data[DOMAIN].pop(self.instance_name, None)

custom_components/ha_text_ai/manifest.json

@@ -23,6 +23,6 @@
   "single_config_entry": false,
   "ssdp": [],
   "usb": [],
-  "version": "2.0.0",
+  "version": "2.0.4-beta",
   "zeroconf": []
 }

custom_components/ha_text_ai/sensor.py

@@ -1,4 +1,11 @@
-"""Sensor platform for HA Text AI."""
+"""
+Sensor platform for HA Text AI.
+
+@license: CC BY-NC-SA 4.0 International
+@author: SMKRV
+@github: https://github.com/smkrv/ha-text-ai
+@source: https://github.com/smkrv/ha-text-ai
+"""
 import logging
 import math
 from typing import Any, Dict
@@ -58,25 +65,39 @@ from .const import (
     ENTITY_ICON,
     ENTITY_ICON_ERROR,
     ENTITY_ICON_PROCESSING,
+    DEFAULT_NAME_PREFIX,
+    CONF_MAX_HISTORY_SIZE,
 )
 
 from .coordinator import HATextAICoordinator
 
 _LOGGER = logging.getLogger(__name__)
 
+
 async def async_setup_entry(
     hass: HomeAssistant,
     entry: ConfigEntry,
     async_add_entities: AddEntitiesCallback,
 ) -> None:
     """Set up the HA Text AI sensor."""
-    coordinator = hass.data[DOMAIN][entry.entry_id]
-    instance_name = coordinator.instance_name
+    _LOGGER.debug(f"Starting sensor setup for entry: {entry.entry_id}")
 
-    _LOGGER.debug(f"Setting up sensor with instance: {instance_name}")
+    try:
+        coordinator = hass.data[DOMAIN][entry.entry_id]
+        _LOGGER.debug(f"Found coordinator for entry {entry.entry_id}")
 
-    sensor = HATextAISensor(coordinator, entry)
-    async_add_entities([sensor], True)
+        instance_name = coordinator.instance_name
+        _LOGGER.debug(f"Setting up sensor with instance: {instance_name}")
+
+        sensor = HATextAISensor(coordinator, entry)
+        _LOGGER.debug(f"Created sensor instance: {sensor.entity_id}")
+
+        async_add_entities([sensor], True)
+        _LOGGER.debug(f"Added sensor entity: {sensor.entity_id}")
+
+    except Exception as err:
+        _LOGGER.exception(f"Error setting up sensor: {err}")
+        raise
 
 class HATextAISensor(CoordinatorEntity, SensorEntity):
     """HA Text AI Sensor."""
@@ -89,19 +110,30 @@ class HATextAISensor(CoordinatorEntity, SensorEntity):
         config_entry: ConfigEntry,
     ) -> None:
         """Initialize the sensor."""
+        _LOGGER.debug(f"Initializing sensor with config entry: {config_entry.data}")
+
         super().__init__(coordinator)
 
         self._config_entry = config_entry
         self._instance_name = coordinator.instance_name
+        self._normalized_name = coordinator.normalized_name
+
+        _LOGGER.debug(f"Instance name: {self._instance_name}")
+        _LOGGER.debug(f"Normalized name: {self._normalized_name}")
+
         self._conversation_history = []
         self._system_prompt = None
 
         self._attr_name = f"HA Text AI {self._instance_name}"
-        self.entity_id = f"sensor.ha_text_ai_{slugify(self._instance_name)}"
+        self.entity_id = f"sensor.ha_text_ai_{self._normalized_name}"
         self._attr_unique_id = f"{config_entry.entry_id}"
 
+        _LOGGER.debug(f"Created sensor with entity_id: {self.entity_id}")
+        _LOGGER.debug(f"Sensor name: {self._attr_name}")
+        _LOGGER.debug(f"Unique ID: {self._attr_unique_id}")
+
         self.entity_description = SensorEntityDescription(
-            key=f"ha_text_ai_{self._instance_name}",
+            key=f"ha_text_ai_{self._normalized_name.lower()}",
             entity_registry_enabled_default=True,
         )
 
@@ -118,13 +150,15 @@ class HATextAISensor(CoordinatorEntity, SensorEntity):
 
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, self._attr_unique_id)},
-            name=self._attr_name,  # Используем имя сенсора
+            name=self._attr_name,
             manufacturer="Community",
             model=f"{model} ({api_provider} provider)",
             sw_version="1.0.0",
         )
 
-        _LOGGER.debug(f"Initialized sensor: {self.entity_id} for instance: {self._instance_name}")
+        _LOGGER.debug(
+            f"Initialized sensor: {self.entity_id} for instance: {self._instance_name}"
+        )
 
     @property
     def available(self) -> bool:
@@ -180,11 +214,14 @@ class HATextAISensor(CoordinatorEntity, SensorEntity):
             data = self.coordinator.data
             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,
                 "instance_name": self._instance_name,
+                "normalized_name": self._normalized_name,
                 ATTR_SYSTEM_PROMPT: data.get("system_prompt"),
                 ATTR_IS_PROCESSING: data.get("is_processing", False),
                 ATTR_IS_RATE_LIMITED: data.get("is_rate_limited", False),
@@ -199,32 +236,40 @@ class HATextAISensor(CoordinatorEntity, SensorEntity):
             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")),
-                })
+                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")),
+                    }
+                )
 
             # Add last response
             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"),
-                })
+                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]
+                attributes[ATTR_PERFORMANCE_METRICS] = data[
+                    ATTR_PERFORMANCE_METRICS
+                ]
 
             # Add API version if available
             if ATTR_API_VERSION in data:
@@ -288,7 +333,7 @@ class HATextAISensor(CoordinatorEntity, SensorEntity):
                 "Error handling update for %s: %s",
                 self.entity_id,
                 err,
-                exc_info=True
+                exc_info=True,
             )
 
         self.async_write_ha_state()

custom_components/ha_text_ai/services.yaml

@@ -40,15 +40,14 @@ ask_question:
           min: 1
           max: 20
           step: 1
-          mode: box
+          mode: slider
 
     model:
       name: Model
       description: "Select AI model to use (optional, overrides default setting)"
       required: false
-      selector:  
-        text:
-          multiline: false
+      selector:
+        text: {}
 
     temperature:
       name: Temperature
@@ -73,3 +72,98 @@ ask_question:
           max: 4096
           step: 1
           mode: box
+
+clear_history:
+  name: Clear History
+  description: >-
+    Delete all stored questions and responses from the conversation history
+  fields:
+    instance:
+      name: Instance
+      description: Name of the HA Text AI instance to clear history for
+      required: true
+      selector:
+        entity:
+          integration: ha_text_ai
+          domain: sensor
+
+get_history:
+  name: Get History
+  description: Retrieve conversation history with optional filtering and sorting
+  fields:
+    instance:
+      name: Instance
+      description: Name of the HA Text AI instance to get history from
+      required: true
+      selector:
+        entity:
+          integration: ha_text_ai
+          domain: sensor
+
+    limit:
+      name: Limit
+      description: Number of conversations to return (1-100)
+      required: false
+      default: 10
+      selector:
+        number:
+          min: 1
+          max: 100
+          step: 1
+          mode: box
+
+    filter_model:
+      name: Filter Model
+      description: Filter conversations by specific AI model
+      required: false
+      selector:
+        text:
+          multiline: false
+
+    start_date:
+      name: Start Date
+      description: Filter conversations starting from this date/time
+      required: false
+      selector:
+        text:
+          multiline: false
+
+    include_metadata:
+      name: Include Metadata
+      description: Include additional information like tokens used, response time, etc.
+      required: false
+      default: false
+      selector:
+        boolean:
+
+    sort_order:
+      name: Sort Order
+      description: Sort order for results (newest or oldest first)
+      required: false
+      default: newest
+      selector:
+        select:
+          options:
+            - newest
+            - oldest
+
+set_system_prompt:
+  name: Set System Prompt
+  description: Set default system behavior instructions for all future conversations
+  fields:
+    instance:
+      name: Instance
+      description: Name of the HA Text AI instance to set system prompt for
+      required: true
+      selector:
+        entity:
+          integration: ha_text_ai
+          domain: sensor
+
+    prompt:
+      name: System Prompt
+      description: Instructions that define how the AI should behave and respond
+      required: true
+      selector:
+        text:
+          multiline: true

custom_components/ha_text_ai/translations/de.json

@@ -1,261 +1,266 @@
 {
-    "config": {
-        "step": {
-            "provider": {
-                "title": "KI-Anbieter auswählen",
-                "description": "Wählen Sie den KI-Dienst-Anbieter für diese Instanz",
-                "data": {
-                    "api_provider": "API-Anbieter",
-                    "context_messages": "Anzahl der zu speichernden Kontextnachrichten (1-20)"
-                }
-            },
-            "user": {
-                "title": "HA Text AI Instanz konfigurieren",
-                "description": "Richten Sie eine neue KI-Assistenten-Instanz mit Ihrem ausgewählten Anbieter ein",
-                "data": {
-                    "name": "Instanzname (z.B. 'GPT Assistent', 'Claude Helfer')",
-                    "api_key": "API-Schlüssel für Authentifizierung",
-                    "model": "Zu verwendendes KI-Modell",
-                    "temperature": "Antwort-Kreativität (0-2, niedriger = fokussierter)",
-                    "max_tokens": "Maximale Antwortlänge (1-4096 Token)",
-                    "api_endpoint": "Benutzerdefinierte API-Endpunkt-URL (optional)",
-                    "request_interval": "Minimale Zeit zwischen Anfragen (0,1-60 Sekunden)",
-                    "context_messages": "Anzahl der zu speichernden Kontextnachrichten (1-20)"
-                }
-            }
-        },
-        "error": {
-            "name_exists": "Eine Instanz mit diesem Namen existiert bereits",
-            "invalid_name": "Ungültiger Instanzname",
-            "invalid_auth": "Authentifizierung fehlgeschlagen - überprüfen Sie Ihren API-Schlüssel",
-            "invalid_api_key": "Ungültiger API-Schlüssel - bitte überprüfen Sie Ihre Anmeldedaten",
-            "cannot_connect": "Verbindung zum API-Dienst fehlgeschlagen",
-            "invalid_model": "Ausgewähltes Modell ist nicht verfügbar",
-            "rate_limit": "Anfragelimit überschritten",
-            "context_length": "Kontextlänge überschritten",
-            "rate_limit_exceeded": "API-Anfragelimit überschritten",
-            "maintenance": "Dienst ist in Wartung",
-            "invalid_response": "Ungültige API-Antwort erhalten",
-            "api_error": "API-Dienst-Fehler aufgetreten",
-            "timeout": "Anfrage-Zeitüberschreitung",
-            "invalid_instance": "Ungültige Instanz angegeben",
-            "unknown": "Unerwarteter Fehler aufgetreten"
+  "config": {
+    "step": {
+      "provider": {
+        "title": "KI-Anbieter auswählen",
+        "description": "Wählen Sie den KI-Dienstanbieter für diese Instanz aus.",
+        "data": {
+          "api_provider": "API-Anbieter",
+          "context_messages": "Anzahl der zu behaltenden Kontextnachrichten (1-20)"
         }
+      },
+      "user": {
+        "title": "HA Text AI-Instanz konfigurieren",
+        "description": "Richten Sie eine neue KI-Assistenteninstanz mit Ihrem ausgewählten Anbieter ein.",
+        "data": {
+          "name": "Instanzname (z. B. 'GPT-Assistent', 'Claude-Helfer')",
+          "api_key": "API-Schlüssel zur Authentifizierung",
+          "model": "Zu verwendendes KI-Modell",
+          "temperature": "Antwortkreativität (0-2, niedriger = fokussierter)",
+          "max_tokens": "Maximale Antwortlänge (1-4096 Token)",
+          "api_endpoint": "Benutzerdefinierte API-Endpunkt-URL (optional)",
+          "api_provider": "API-Anbieter",
+          "request_interval": "Mindestzeit zwischen Anfragen (0,1-60 Sekunden)",
+          "context_messages": "Anzahl der zu behaltenden Kontextnachrichten (1-20)",
+          "max_history_size": "Maximale Größe des Konversationsverlaufs (1-100)"
+        }
+      }
     },
-    "options": {
-        "step": {
-            "init": {
-                "title": "Instanzeinstellungen aktualisieren",
-                "description": "Einstellungen für diese KI-Assistenten-Instanz ändern",
-                "data": {
-                    "model": "KI-Modell",
-                    "temperature": "Antwort-Kreativität (0-2)",
-                    "max_tokens": "Maximale Antwortlänge (1-4096)",
-                    "request_interval": "Minimales Anfragen-Intervall (0,1-60 Sekunden)",
-                    "context_messages": "Anzahl der vorherigen Nachrichten, die in den Kontext einbezogen werden sollen (1-20)"
-
-                }
-            }
-        }
-    },
-    "services": {
-        "ask_question": {
-            "name": "Frage stellen (HA Text AI)",
-            "description": "Senden Sie eine Frage an das KI-Modell und erhalten Sie eine detaillierte Antwort. Die Antwort wird in der Gesprächshistorie gespeichert und kann später abgerufen werden.",
-            "fields": {
-                "instance": {
-                    "name": "Instanz",
-                    "description": "Name der zu verwendenden HA Text AI Instanz"
-                },
-                "question": {
-                    "name": "Frage",
-                    "description": "Ihre Frage oder Eingabeaufforderung für den KI-Assistenten"
-                },
-                "context_messages": {
-                    "name": "Kontextnachrichten",
-                    "description": "Anzahl der vorherigen Nachrichten, die in den Kontext einbezogen werden sollen (1-20)"
-                },
-                "system_prompt": {
-                    "name": "Systemaufforderung",
-                    "description": "Optionale Systemaufforderung zur Kontexteinstellung für diese spezifische Frage"
-                },
-                "model": {
-                    "name": "Modell",
-                    "description": "Wählen Sie das zu verwendende KI-Modell (optional, überschreibt Standardeinstellung)"
-                },
-                "temperature": {
-                    "name": "Temperatur",
-                    "description": "Steuert die Antwort-Kreativität (0,0-2,0)"
-                },
-                "max_tokens": {
-                    "name": "Max. Token",
-                    "description": "Maximale Länge der Antwort (1-4096 Token)"
-                }
-            }
-        },
-        "clear_history": {
-            "name": "Verlauf löschen",
-            "description": "Alle gespeicherten Fragen und Antworten aus dem Gesprächsverlauf löschen",
-            "fields": {
-                "instance": {
-                    "name": "Instanz",
-                    "description": "Name der HA Text AI Instanz, für die der Verlauf gelöscht werden soll"
-                }
-            }
-        },
-        "get_history": {
-            "name": "Verlauf abrufen",
-            "description": "Gesprächsverlauf mit optionaler Filterung und Sortierung abrufen",
-            "fields": {
-                "instance": {
-                    "name": "Instanz",
-                    "description": "Name der HA Text AI Instanz, aus der der Verlauf abgerufen werden soll"
-                },
-                "limit": {
-                    "name": "Limit",
-                    "description": "Anzahl der zurückzugebenden Gespräche (1-100)"
-                },
-                "filter_model": {
-                    "name": "Modell filtern",
-                    "description": "Gespräche nach bestimmtem KI-Modell filtern"
-                },
-                "start_date": {
-                    "name": "Startdatum",
-                    "description": "Gespräche ab diesem Datum/Zeitpunkt filtern"
-                },
-                "include_metadata": {
-                    "name": "Metadaten einbeziehen",
-                    "description": "Zusätzliche Informationen wie verwendete Token, Antwortzeit usw. einbeziehen"
-                },
-                "sort_order": {
-                    "name": "Sortierreihenfolge",
-                    "description": "Sortierreihenfolge der Ergebnisse (neueste oder älteste zuerst)"
-                }
-            }
-        },
-        "set_system_prompt": {
-            "name": "Systemaufforderung festlegen",
-            "description": "Standardmäßige Systemverhaltensinstruktionen für alle zukünftigen Gespräche festlegen",
-            "fields": {
-                "instance": {
-                    "name": "Instanz",
-                    "description": "Name der HA Text AI Instanz, für die die Systemaufforderung festgelegt werden soll"
-                },
-                "prompt": {
-                    "name": "Systemaufforderung",
-                    "description": "Anweisungen, die definieren, wie sich die KI verhalten und antworten soll"
-                }
-            }
-        }
-    },
-    "entity": {
-        "sensor": {
-            "ha_text_ai": {
-                "name": "{name}",
-                "state": {
-                    "ready": "Bereit",
-                    "processing": "Verarbeitung",
-                    "error": "Fehler",
-                    "disconnected": "Getrennt",
-                    "rate_limited": "Anfragelimit",
-                    "maintenance": "Wartung",
-                    "initializing": "Initialisierung",
-                    "retrying": "Wiederholung",
-                    "queued": "In Warteschlange"
-                },
-                "state_attributes": {
-                    "question": {
-                        "name": "Letzte Frage"
-                    },
-                    "response": {
-                        "name": "Letzte Antwort"
-                    },
-                    "model": {
-                        "name": "Aktuelles Modell"
-                    },
-                    "temperature": {
-                        "name": "Temperatur"
-                    },
-                    "max_tokens": {
-                        "name": "Max. Token"
-                    },
-                    "system_prompt": {
-                        "name": "Systemaufforderung"
-                    },
-                    "response_time": {
-                        "name": "Letzte Antwortzeit"
-                    },
-                    "total_responses": {
-                        "name": "Gesamte Antworten"
-                    },
-                    "error_count": {
-                        "name": "Fehleranzahl"
-                    },
-                    "last_error": {
-                        "name": "Letzter Fehler"
-                    },
-                    "api_status": {
-                        "name": "API-Status"
-                    },
-                    "tokens_used": {
-                        "name": "Insgesamt verwendete Token"
-                    },
-                    "average_response_time": {
-                        "name": "Durchschnittliche Antwortzeit"
-                    },
-                    "last_request_time": {
-                        "name": "Letzte Anforderungszeit"
-                    },
-                    "is_processing": {
-                        "name": "Verarbeitungsstatus"
-                    },
-                    "is_rate_limited": {
-                        "name": "Status Anfragelimit"
-                    },
-                    "is_maintenance": {
-                        "name": "Wartungsstatus"
-                    },
-                    "api_version": {
-                        "name": "API-Version"
-                    },
-                    "endpoint_status": {
-                        "name": "Endpunktstatus"
-                    },
-                    "performance_metrics": {
-                        "name": "Leistungsmetriken"
-                    },
-                    "history_size": {
-                        "name": "Verlaufsgröße"
-                    },
-                    "uptime": {
-                        "name": "Betriebszeit"
-                    },
-                    "total_tokens": {
-                        "name": "Gesamte Token"
-                    },
-                    "prompt_tokens": {
-                        "name": "Prompt-Token"
-                    },
-                    "completion_tokens": {
-                        "name": "Abschluss-Token"
-                    },
-                    "successful_requests": {
-                        "name": "Erfolgreiche Anfragen"
-                    },
-                    "failed_requests": {
-                        "name": "Fehlgeschlagene Anfragen"
-                    },
-                    "average_latency": {
-                        "name": "Durchschnittliche Latenz"
-                    },
-                    "max_latency": {
-                        "name": "Maximale Latenz"
-                    },
-                    "min_latency": {
-                        "name": "Minimale Latenz"
-                    }
-                }
-            }
-        }
+    "error": {
+      "name_exists": "Eine Instanz mit diesem Namen existiert bereits",
+      "invalid_name": "Ungültiger Instanzname",
+      "invalid_auth": "Authentifizierung fehlgeschlagen - überprüfen Sie Ihren API-Schlüssel",
+      "invalid_api_key": "Ungültiger API-Schlüssel - überprüfen Sie Ihre Anmeldedaten",
+      "cannot_connect": "Verbindung zum API-Dienst fehlgeschlagen",
+      "invalid_model": "Das ausgewählte Modell ist nicht verfügbar",
+      "rate_limit": "Ratenlimit überschritten",
+      "context_length": "Kontextlänge überschritten",
+      "rate_limit_exceeded": "API-Ratenlimit überschritten",
+      "maintenance": "Dienst befindet sich in der Wartung",
+      "invalid_response": "Ungültige API-Antwort empfangen",
+      "api_error": "Fehler im API-Dienst aufgetreten",
+      "timeout": "Anfrage ist abgelaufen",
+      "invalid_instance": "Ungültige Instanz angegeben",
+      "unknown": "Es ist ein unerwarteter Fehler aufgetreten",
+      "empty": "Name darf nicht leer sein",
+      "invalid_characters": "Name darf nur Buchstaben, Zahlen, Leerzeichen, Unterstriche und Bindestriche enthalten",
+      "name_too_long": "Name darf maximal 50 Zeichen lang sein"
     }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "title": "Instanzeinstellungen aktualisieren",
+        "description": "Ändern Sie die Einstellungen für diese KI-Assistenteninstanz.",
+        "data": {
+          "model": "KI-Modell",
+          "temperature": "Antwortkreativität (0-2)",
+          "max_tokens": "Maximale Antwortlänge (1-4096)",
+          "request_interval": "Mindestzeitraum zwischen Anfragen (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 Konversationsverlaufs (1-100)"
+        }
+      }
+    }
+  },
+  "services": {
+    "ask_question": {
+      "name": "Frage stellen (HA Text AI)",
+      "description": "Senden Sie eine Frage an das KI-Modell und erhalten Sie eine detaillierte Antwort. Die Antwort wird im Konversationsverlauf gespeichert und kann später abgerufen werden.",
+      "fields": {
+        "instance": {
+          "name": "Instanz",
+          "description": "Name der zu verwendenden HA Text AI-Instanz"
+        },
+        "question": {
+          "name": "Frage",
+          "description": "Ihre Frage oder Aufforderung an den KI-Assistenten"
+        },
+        "context_messages": {
+          "name": "Kontextnachrichten",
+          "description": "Anzahl der vorherigen Nachrichten, die im Kontext enthalten sein sollen (1-20)"
+        },
+        "system_prompt": {
+          "name": "Systemprompt",
+          "description": "Optionaler Systemprompt, um den Kontext für diese spezielle Frage festzulegen"
+        },
+        "model": {
+          "name": "Modell",
+          "description": "Wählen Sie das zu verwendende KI-Modell aus (optional, überschreibt die Standardeinstellung)"
+        },
+        "temperature": {
+          "name": "Temperatur",
+          "description": "Steuert die Antwortkreativität (0.0-2.0)"
+        },
+        "max_tokens": {
+          "name": "Max. Token",
+          "description": "Maximale Länge der Antwort (1-4096 Token)"
+        }
+      }
+    },
+    "clear_history": {
+      "name": "Verlauf löschen",
+      "description": "Alle gespeicherten Fragen und Antworten aus dem Konversationsverlauf löschen",
+      "fields": {
+        "instance": {
+          "name": "Instanz",
+          "description": "Name der HA Text AI-Instanz, deren Verlauf gelöscht werden soll"
+        }
+      }
+    },
+    "get_history": {
+      "name": "Verlauf abrufen",
+      "description": "Konversationsverlauf mit optionalem Filtern und Sortieren abrufen",
+      "fields": {
+        "instance": {
+          "name": "Instanz",
+          "description": "Name der HA Text AI-Instanz, von der der Verlauf abgerufen werden soll"
+        },
+        "limit": {
+          "name": "Limit",
+          "description": "Anzahl der zurückzugebenden Konversationen (1-100)"
+        },
+        "filter_model": {
+          "name": "Modell filtern",
+          "description": "Konversationen nach einem bestimmten KI-Modell filtern"
+        },
+        "start_date": {
+          "name": "Startdatum",
+          "description": "Konversationen ab diesem Datum/Uhrzeit filtern"
+        },
+        "include_metadata": {
+          "name": "Metadaten einschließen",
+          "description": "Zusätzliche Informationen wie verwendete Token, Antwortzeit usw. einschließen"
+        },
+        "sort_order": {
+          "name": "Sortierreihenfolge",
+          "description": "Sortierreihenfolge für die Ergebnisse (neueste oder älteste zuerst)"
+        }
+      }
+    },
+    "set_system_prompt": {
+      "name": "Systemprompt festlegen",
+      "description": "Legen Sie Standardanweisungen für das Systemverhalten für alle zukünftigen Konversationen fest",
+      "fields": {
+        "instance": {
+          "name": "Instanz",
+          "description": "Name der HA Text AI-Instanz, für die der Systemprompt festgelegt werden soll"
+        },
+        "prompt": {
+          "name": "Systemprompt",
+          "description": "Anweisungen, die definieren, wie sich die KI verhalten und antworten soll"
+        }
+      }
+    }
+  },
+  "entity": {
+    "sensor": {
+      "ha_text_ai": {
+        "name": "{name}",
+        "state": {
+          "ready": "Bereit",
+          "processing": "Verarbeitung",
+          "error": "Fehler",
+          "disconnected": "Getrennt",
+          "rate_limited": "Ratenlimit",
+          "maintenance": "Wartung",
+          "initializing": "Initialisierung",
+          "retrying": "Wiederholen",
+          "queued": "Warteschlange"
+        },
+        "state_attributes": {
+          "question": {
+            "name": "Letzte Frage"
+          },
+          "response": {
+            "name": "Letzte Antwort"
+          },
+          "model": {
+            "name": "Aktuelles Modell"
+          },
+          "temperature": {
+            "name": "Temperatur"
+          },
+          "max_tokens": {
+            "name": "Max. Token"
+          },
+          "system_prompt": {
+            "name": "Systemprompt"
+          },
+          "response_time": {
+            "name": "Letzte Antwortzeit"
+          },
+          "total_responses": {
+            "name": "Gesamtzahl der Antworten"
+          },
+          "error_count": {
+            "name": "Fehleranzahl"
+          },
+          "last_error": {
+            "name": "Letzter Fehler"
+          },
+          "api_status": {
+            "name": "API-Status"
+          },
+          "tokens_used": {
+            "name": "Verwendete Token insgesamt"
+          },
+          "average_response_time": {
+            "name": "Durchschnittliche Antwortzeit"
+          },
+          "last_request_time": {
+            "name": "Zeitpunkt der letzten Anfrage"
+          },
+          "is_processing": {
+            "name": "Verarbeitungsstatus"
+          },
+          "is_rate_limited": {
+            "name": "Ratenlimit-Status"
+          },
+          "is_maintenance": {
+            "name": "Wartungsstatus"
+          },
+          "api_version": {
+            "name": "API-Version"
+          },
+          "endpoint_status": {
+            "name": "Endpunkt-Status"
+          },
+          "performance_metrics": {
+            "name": "Leistungsmetriken"
+          },
+          "history_size": {
+            "name": "Verlaufsgröße"
+          },
+          "uptime": {
+            "name": "Betriebszeit"
+          },
+          "total_tokens": {
+            "name": "Gesamtzahl der Token"
+          },
+          "prompt_tokens": {
+            "name": "Prompt-Token"
+          },
+          "completion_tokens": {
+            "name": "Completion-Token"
+          },
+          "successful_requests": {
+            "name": "Erfolgreiche Anfragen"
+          },
+          "failed_requests": {
+            "name": "Fehlgeschlagene Anfragen"
+          },
+          "average_latency": {
+            "name": "Durchschnittliche Latenz"
+          },
+          "max_latency": {
+            "name": "Maximale Latenz"
+          },
+          "min_latency": {
+            "name": "Minimale Latenz"
+          }
+        }
+      }
+    }
+  }
 }

custom_components/ha_text_ai/translations/en.json

@@ -1,260 +1,266 @@
 {
-    "config": {
-        "step": {
-            "provider": {
-                "title": "Select AI Provider",
-                "description": "Choose which AI service provider to use for this instance",
-                "data": {
-                    "api_provider": "API Provider",
-                    "context_messages": "Number of context messages to retain (1-20)"
-                }
-            },
-            "user": {
-                "title": "Configure HA Text AI Instance",
-                "description": "Set up a new AI assistant instance with your selected provider",
-                "data": {
-                    "name": "Instance name (e.g., 'GPT Assistant', 'Claude Helper')",
-                    "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)",
-                    "api_endpoint": "Custom API endpoint URL (optional)",
-                    "request_interval": "Minimum time between requests (0.1-60 seconds)",
-                    "context_messages": "Number of context messages to retain (1-20)"
-                }
-            }
-        },
-        "error": {
-            "name_exists": "An instance with this name already exists",
-            "invalid_name": "Invalid instance name",
-            "invalid_auth": "Authentication failed - check your API key",
-            "invalid_api_key": "Invalid API key - please verify your credentials",
-            "cannot_connect": "Failed to connect to API service",
-            "invalid_model": "Selected model is not available",
-            "rate_limit": "Rate limit exceeded",
-            "context_length": "Context length exceeded",
-            "rate_limit_exceeded": "API rate limit exceeded",
-            "maintenance": "Service is under maintenance",
-            "invalid_response": "Invalid API response received",
-            "api_error": "API service error occurred",
-            "timeout": "Request timed out",
-            "invalid_instance": "Invalid instance specified",
-            "unknown": "Unexpected error occurred"
+  "config": {
+    "step": {
+      "provider": {
+        "title": "Select AI Provider",
+        "description": "Choose which AI service provider to use for this instance.",
+        "data": {
+          "api_provider": "API Provider",
+          "context_messages": "Number of context messages to retain (1-20)"
         }
+      },
+      "user": {
+        "title": "Configure HA Text AI Instance",
+        "description": "Set up a new AI assistant instance with your selected provider.",
+        "data": {
+          "name": "Instance name (e.g., 'GPT Assistant', 'Claude Helper')",
+          "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)",
+          "api_endpoint": "Custom API endpoint URL (optional)",
+          "api_provider": "API Provider",
+          "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)"
+        }
+      }
     },
-    "options": {
-        "step": {
-            "init": {
-                "title": "Update Instance Settings",
-                "description": "Modify settings for this AI assistant instance",
-                "data": {
-                    "model": "AI model",
-                    "temperature": "Response creativity (0-2)",
-                    "max_tokens": "Maximum response length (1-4096)",
-                    "request_interval": "Minimum request interval (0.1-60 seconds)",
-                    "context_messages": "Number of previous messages to include in context (1-20)"
-                }
-            }
-        }
-    },
-    "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.",
-            "fields": {
-                "instance": {
-                    "name": "Instance",
-                    "description": "Name of the HA Text AI instance to use"
-                },
-                "question": {
-                    "name": "Question",
-                    "description": "Your question or prompt for the AI assistant"
-                },
-                "context_messages": {
-                    "name": "Context Messages",
-                    "description": "Number of previous messages to include in context (1-20)"
-                },
-                "system_prompt": {
-                    "name": "System Prompt",
-                    "description": "Optional system prompt to set context for this specific question"
-                },
-                "model": {
-                    "name": "Model",
-                    "description": "Select AI model to use (optional, overrides default setting)"
-                },
-                "temperature": {
-                    "name": "Temperature",
-                    "description": "Controls response creativity (0.0-2.0)"
-                },
-                "max_tokens": {
-                    "name": "Max Tokens",
-                    "description": "Maximum length of the response (1-4096 tokens)"
-                }
-            }
-        },
-        "clear_history": {
-            "name": "Clear History",
-            "description": "Delete all stored questions and responses from the conversation history",
-            "fields": {
-                "instance": {
-                    "name": "Instance",
-                    "description": "Name of the HA Text AI instance to clear history for"
-                }
-            }
-        },
-        "get_history": {
-            "name": "Get History",
-            "description": "Retrieve conversation history with optional filtering and sorting",
-            "fields": {
-                "instance": {
-                    "name": "Instance",
-                    "description": "Name of the HA Text AI instance to get history from"
-                },
-                "limit": {
-                    "name": "Limit",
-                    "description": "Number of conversations to return (1-100)"
-                },
-                "filter_model": {
-                    "name": "Filter Model",
-                    "description": "Filter conversations by specific AI model"
-                },
-                "start_date": {
-                    "name": "Start Date",
-                    "description": "Filter conversations starting from this date/time"
-                },
-                "include_metadata": {
-                    "name": "Include Metadata",
-                    "description": "Include additional information like tokens used, response time, etc."
-                },
-                "sort_order": {
-                    "name": "Sort Order",
-                    "description": "Sort order for results (newest or oldest first)"
-                }
-            }
-        },
-        "set_system_prompt": {
-            "name": "Set System Prompt",
-            "description": "Set default system behavior instructions for all future conversations",
-            "fields": {
-                "instance": {
-                    "name": "Instance",
-                    "description": "Name of the HA Text AI instance to set system prompt for"
-                },
-                "prompt": {
-                    "name": "System Prompt",
-                    "description": "Instructions that define how the AI should behave and respond"
-                }
-            }
-        }
-    },
-    "entity": {
-        "sensor": {
-            "ha_text_ai": {
-                "name": "{name}",
-                "state": {
-                    "ready": "Ready",
-                    "processing": "Processing",
-                    "error": "Error",
-                    "disconnected": "Disconnected",
-                    "rate_limited": "Rate Limited",
-                    "maintenance": "Maintenance",
-                    "initializing": "Initializing",
-                    "retrying": "Retrying",
-                    "queued": "Queued"
-                },
-                "state_attributes": {
-                    "question": {
-                        "name": "Last Question"
-                    },
-                    "response": {
-                        "name": "Last Response"
-                    },
-                    "model": {
-                        "name": "Current Model"
-                    },
-                    "temperature": {
-                        "name": "Temperature"
-                    },
-                    "max_tokens": {
-                        "name": "Max Tokens"
-                    },
-                    "system_prompt": {
-                        "name": "System Prompt"
-                    },
-                    "response_time": {
-                        "name": "Last Response Time"
-                    },
-                    "total_responses": {
-                        "name": "Total Responses"
-                    },
-                    "error_count": {
-                        "name": "Error Count"
-                    },
-                    "last_error": {
-                        "name": "Last Error"
-                    },
-                    "api_status": {
-                        "name": "API Status"
-                    },
-                    "tokens_used": {
-                        "name": "Total Tokens Used"
-                    },
-                    "average_response_time": {
-                        "name": "Average Response Time"
-                    },
-                    "last_request_time": {
-                        "name": "Last Request Time"
-                    },
-                    "is_processing": {
-                        "name": "Processing Status"
-                    },
-                    "is_rate_limited": {
-                        "name": "Rate Limited Status"
-                    },
-                    "is_maintenance": {
-                        "name": "Maintenance Status"
-                    },
-                    "api_version": {
-                        "name": "API Version"
-                    },
-                    "endpoint_status": {
-                        "name": "Endpoint Status"
-                    },
-                    "performance_metrics": {
-                        "name": "Performance Metrics"
-                    },
-                    "history_size": {
-                        "name": "History Size"
-                    },
-                    "uptime": {
-                        "name": "Uptime"
-                    },
-                    "total_tokens": {
-                        "name": "Total Tokens"
-                    },
-                    "prompt_tokens": {
-                        "name": "Prompt Tokens"
-                    },
-                    "completion_tokens": {
-                        "name": "Completion Tokens"
-                    },
-                    "successful_requests": {
-                        "name": "Successful Requests"
-                    },
-                    "failed_requests": {
-                        "name": "Failed Requests"
-                    },
-                    "average_latency": {
-                        "name": "Average Latency"
-                    },
-                    "max_latency": {
-                        "name": "Maximum Latency"
-                    },
-                    "min_latency": {
-                        "name": "Minimum Latency"
-                    }
-                }
-            }
-        }
+    "error": {
+      "name_exists": "An instance with this name already exists",
+      "invalid_name": "Invalid instance name",
+      "invalid_auth": "Authentication failed - check your API key",
+      "invalid_api_key": "Invalid API key - please verify your credentials",
+      "cannot_connect": "Failed to connect to API service",
+      "invalid_model": "Selected model is not available",
+      "rate_limit": "Rate limit exceeded",
+      "context_length": "Context length exceeded",
+      "rate_limit_exceeded": "API rate limit exceeded",
+      "maintenance": "Service is under maintenance",
+      "invalid_response": "Invalid API response received",
+      "api_error": "API service error occurred",
+      "timeout": "Request timed out",
+      "invalid_instance": "Invalid instance specified",
+      "unknown": "Unexpected error occurred",
+      "empty": "Name cannot be empty",
+      "invalid_characters": "Name can only contain letters, numbers, spaces, underscores and hyphens",
+      "name_too_long": "Name must be 50 characters or less"
     }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "title": "Update Instance Settings",
+        "description": "Modify settings for this AI assistant instance.",
+        "data": {
+          "model": "AI model",
+          "temperature": "Response creativity (0-2)",
+          "max_tokens": "Maximum response length (1-4096)",
+          "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)"
+        }
+      }
+    }
+  },
+  "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.",
+      "fields": {
+        "instance": {
+          "name": "Instance",
+          "description": "Name of the HA Text AI instance to use"
+        },
+        "question": {
+          "name": "Question",
+          "description": "Your question or prompt for the AI assistant"
+        },
+        "context_messages": {
+          "name": "Context Messages",
+          "description": "Number of previous messages to include in context (1-20)"
+        },
+        "system_prompt": {
+          "name": "System Prompt",
+          "description": "Optional system prompt to set context for this specific question"
+        },
+        "model": {
+          "name": "Model",
+          "description": "Select AI model to use (optional, overrides default setting)"
+        },
+        "temperature": {
+          "name": "Temperature",
+          "description": "Controls response creativity (0.0-2.0)"
+        },
+        "max_tokens": {
+          "name": "Max Tokens",
+          "description": "Maximum length of the response (1-4096 tokens)"
+        }
+      }
+    },
+    "clear_history": {
+      "name": "Clear History",
+      "description": "Delete all stored questions and responses from the conversation history",
+      "fields": {
+        "instance": {
+          "name": "Instance",
+          "description": "Name of the HA Text AI instance to clear history for"
+        }
+      }
+    },
+    "get_history": {
+      "name": "Get History",
+      "description": "Retrieve conversation history with optional filtering and sorting",
+      "fields": {
+        "instance": {
+          "name": "Instance",
+          "description": "Name of the HA Text AI instance to get history from"
+        },
+        "limit": {
+          "name": "Limit",
+          "description": "Number of conversations to return (1-100)"
+        },
+        "filter_model": {
+          "name": "Filter Model",
+          "description": "Filter conversations by specific AI model"
+        },
+        "start_date": {
+          "name": "Start Date",
+          "description": "Filter conversations starting from this date/time"
+        },
+        "include_metadata": {
+          "name": "Include Metadata",
+          "description": "Include additional information like tokens used, response time, etc."
+        },
+        "sort_order": {
+          "name": "Sort Order",
+          "description": "Sort order for results (newest or oldest first)"
+        }
+      }
+    },
+    "set_system_prompt": {
+      "name": "Set System Prompt",
+      "description": "Set default system behavior instructions for all future conversations",
+      "fields": {
+        "instance": {
+          "name": "Instance",
+          "description": "Name of the HA Text AI instance to set system prompt for"
+        },
+        "prompt": {
+          "name": "System Prompt",
+          "description": "Instructions that define how the AI should behave and respond"
+        }
+      }
+    }
+  },
+  "entity": {
+    "sensor": {
+      "ha_text_ai": {
+        "name": "{name}",
+        "state": {
+          "ready": "Ready",
+          "processing": "Processing",
+          "error": "Error",
+          "disconnected": "Disconnected",
+          "rate_limited": "Rate Limited",
+          "maintenance": "Maintenance",
+          "initializing": "Initializing",
+          "retrying": "Retrying",
+          "queued": "Queued"
+        },
+        "state_attributes": {
+          "question": {
+            "name": "Last Question"
+          },
+          "response": {
+            "name": "Last Response"
+          },
+          "model": {
+            "name": "Current Model"
+          },
+          "temperature": {
+            "name": "Temperature"
+          },
+          "max_tokens": {
+            "name": "Max Tokens"
+          },
+          "system_prompt": {
+            "name": "System Prompt"
+          },
+          "response_time": {
+            "name": "Last Response Time"
+          },
+          "total_responses": {
+            "name": "Total Responses"
+          },
+          "error_count": {
+            "name": "Error Count"
+          },
+          "last_error": {
+            "name": "Last Error"
+          },
+          "api_status": {
+            "name": "API Status"
+          },
+          "tokens_used": {
+            "name": "Total Tokens Used"
+          },
+          "average_response_time": {
+            "name": "Average Response Time"
+          },
+          "last_request_time": {
+            "name": "Last Request Time"
+          },
+          "is_processing": {
+            "name": "Processing Status"
+          },
+          "is_rate_limited": {
+            "name": "Rate Limited Status"
+          },
+          "is_maintenance": {
+            "name": "Maintenance Status"
+          },
+          "api_version": {
+            "name": "API Version"
+          },
+          "endpoint_status": {
+            "name": "Endpoint Status"
+          },
+          "performance_metrics": {
+            "name": "Performance Metrics"
+          },
+          "history_size": {
+            "name": "History Size"
+          },
+          "uptime": {
+            "name": "Uptime"
+          },
+          "total_tokens": {
+            "name": "Total Tokens"
+          },
+          "prompt_tokens": {
+            "name": "Prompt Tokens"
+          },
+          "completion_tokens": {
+            "name": "Completion Tokens"
+          },
+          "successful_requests": {
+            "name": "Successful Requests"
+          },
+          "failed_requests": {
+            "name": "Failed Requests"
+          },
+          "average_latency": {
+            "name": "Average Latency"
+          },
+          "max_latency": {
+            "name": "Maximum Latency"
+          },
+          "min_latency": {
+            "name": "Minimum Latency"
+          }
+        }
+      }
+    }
+  }
 }

custom_components/ha_text_ai/translations/es.json

@@ -0,0 +1,266 @@
+{
+  "config": {
+    "step": {
+      "provider": {
+        "title": "Seleccionar proveedor de IA",
+        "description": "Elige qué proveedor de servicios de IA usar para esta instancia.",
+        "data": {
+          "api_provider": "Proveedor de API",
+          "context_messages": "Número de mensajes de contexto que conservar (1-20)"
+        }
+      },
+      "user": {
+        "title": "Configurar instancia de HA Text AI",
+        "description": "Configura una nueva instancia de asistente de IA con el proveedor seleccionado.",
+        "data": {
+          "name": "Nombre de la instancia (p. ej., 'Asistente GPT', 'Ayudante de Claude')",
+          "api_key": "Clave API para la autenticación",
+          "model": "Modelo de IA a usar",
+          "temperature": "Creatividad de la respuesta (0-2, cuanto menor, más enfocada)",
+          "max_tokens": "Longitud máxima de la respuesta (1-4096 tokens)",
+          "api_endpoint": "URL del punto final de la API personalizada (opcional)",
+          "api_provider": "Proveedor de API",
+          "request_interval": "Tiempo mínimo entre solicitudes (0,1-60 segundos)",
+          "context_messages": "Número de mensajes de contexto que conservar (1-20)",
+          "max_history_size": "Tamaño máximo del historial de conversación (1-100)"
+        }
+      }
+    },
+    "error": {
+      "name_exists": "Ya existe una instancia con este nombre",
+      "invalid_name": "Nombre de instancia no válido",
+      "invalid_auth": "Error de autenticación: comprueba tu clave API",
+      "invalid_api_key": "Clave API no válida: verifica tus credenciales",
+      "cannot_connect": "No se pudo conectar al servicio API",
+      "invalid_model": "El modelo seleccionado no está disponible",
+      "rate_limit": "Límite de tasa excedido",
+      "context_length": "Longitud de contexto excedida",
+      "rate_limit_exceeded": "Límite de tasa de API excedido",
+      "maintenance": "El servicio está en mantenimiento",
+      "invalid_response": "Se recibió una respuesta de API no válida",
+      "api_error": "Se produjo un error en el servicio API",
+      "timeout": "Tiempo de espera de la solicitud agotado",
+      "invalid_instance": "Instancia especificada no válida",
+      "unknown": "Se produjo un error inesperado",
+      "empty": "El nombre no puede estar vacío",
+      "invalid_characters": "El nombre solo puede contener letras, números, espacios, guiones bajos y guiones",
+      "name_too_long": "El nombre debe tener 50 caracteres o menos"
+    }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "title": "Actualizar configuración de la instancia",
+        "description": "Modifica la configuración de esta instancia de asistente de IA.",
+        "data": {
+          "model": "Modelo de IA",
+          "temperature": "Creatividad de la respuesta (0-2)",
+          "max_tokens": "Longitud máxima de la respuesta (1-4096)",
+          "request_interval": "Intervalo mínimo de solicitud (0,1-60 segundos)",
+          "context_messages": "Número de mensajes anteriores que se incluirán en el contexto (1-20)",
+          "max_history_size": "Tamaño máximo del historial de conversación (1-100)"
+        }
+      }
+    }
+  },
+  "services": {
+    "ask_question": {
+      "name": "Hacer pregunta (HA Text AI)",
+      "description": "Envía una pregunta al modelo de IA y recibe una respuesta detallada. La respuesta se almacenará en el historial de conversación y se podrá recuperar más tarde.",
+      "fields": {
+        "instance": {
+          "name": "Instancia",
+          "description": "Nombre de la instancia de HA Text AI a utilizar"
+        },
+        "question": {
+          "name": "Pregunta",
+          "description": "Tu pregunta o indicación para el asistente de IA"
+        },
+        "context_messages": {
+          "name": "Mensajes de contexto",
+          "description": "Número de mensajes anteriores que se incluirán en el contexto (1-20)"
+        },
+        "system_prompt": {
+          "name": "Indicación del sistema",
+          "description": "Indicación del sistema opcional para establecer el contexto de esta pregunta específica"
+        },
+        "model": {
+          "name": "Modelo",
+          "description": "Selecciona el modelo de IA que se va a utilizar (opcional, anula la configuración predeterminada)"
+        },
+        "temperature": {
+          "name": "Temperatura",
+          "description": "Controla la creatividad de la respuesta (0.0-2.0)"
+        },
+        "max_tokens": {
+          "name": "Máx. tokens",
+          "description": "Longitud máxima de la respuesta (1-4096 tokens)"
+        }
+      }
+    },
+    "clear_history": {
+      "name": "Borrar historial",
+      "description": "Elimina todas las preguntas y respuestas almacenadas del historial de conversación",
+      "fields": {
+        "instance": {
+          "name": "Instancia",
+          "description": "Nombre de la instancia de HA Text AI para la que se va a borrar el historial"
+        }
+      }
+    },
+    "get_history": {
+      "name": "Obtener historial",
+      "description": "Recupera el historial de conversaciones con filtrado y ordenación opcionales",
+      "fields": {
+        "instance": {
+          "name": "Instancia",
+          "description": "Nombre de la instancia de HA Text AI de la que se va a obtener el historial"
+        },
+        "limit": {
+          "name": "Límite",
+          "description": "Número de conversaciones que se van a devolver (1-100)"
+        },
+        "filter_model": {
+          "name": "Filtrar modelo",
+          "description": "Filtra las conversaciones por un modelo de IA específico"
+        },
+        "start_date": {
+          "name": "Fecha de inicio",
+          "description": "Filtra las conversaciones a partir de esta fecha/hora"
+        },
+        "include_metadata": {
+          "name": "Incluir metadatos",
+          "description": "Incluir información adicional como los tokens utilizados, el tiempo de respuesta, etc."
+        },
+        "sort_order": {
+          "name": "Orden de clasificación",
+          "description": "Orden de clasificación de los resultados (más recientes o más antiguos primero)"
+        }
+      }
+    },
+    "set_system_prompt": {
+      "name": "Establecer indicación del sistema",
+      "description": "Establece instrucciones predeterminadas de comportamiento del sistema para todas las conversaciones futuras",
+      "fields": {
+        "instance": {
+          "name": "Instancia",
+          "description": "Nombre de la instancia de HA Text AI para la que se va a establecer la indicación del sistema"
+        },
+        "prompt": {
+          "name": "Indicación del sistema",
+          "description": "Instrucciones que definen cómo debe comportarse y responder la IA"
+        }
+      }
+    }
+  },
+  "entity": {
+    "sensor": {
+      "ha_text_ai": {
+        "name": "{name}",
+        "state": {
+          "ready": "Listo",
+          "processing": "Procesando",
+          "error": "Error",
+          "disconnected": "Desconectado",
+          "rate_limited": "Límite de tasa alcanzado",
+          "maintenance": "Mantenimiento",
+          "initializing": "Inicializando",
+          "retrying": "Reintentando",
+          "queued": "En cola"
+        },
+        "state_attributes": {
+          "question": {
+            "name": "Última pregunta"
+          },
+          "response": {
+            "name": "Última respuesta"
+          },
+          "model": {
+            "name": "Modelo actual"
+          },
+          "temperature": {
+            "name": "Temperatura"
+          },
+          "max_tokens": {
+            "name": "Máx. tokens"
+          },
+          "system_prompt": {
+            "name": "Indicación del sistema"
+          },
+          "response_time": {
+            "name": "Tiempo de la última respuesta"
+          },
+          "total_responses": {
+            "name": "Total de respuestas"
+          },
+          "error_count": {
+            "name": "Recuento de errores"
+          },
+          "last_error": {
+            "name": "Último error"
+          },
+          "api_status": {
+            "name": "Estado de la API"
+          },
+          "tokens_used": {
+            "name": "Total de tokens usados"
+          },
+          "average_response_time": {
+            "name": "Tiempo medio de respuesta"
+          },
+          "last_request_time": {
+            "name": "Tiempo de la última solicitud"
+          },
+          "is_processing": {
+            "name": "Estado de procesamiento"
+          },
+          "is_rate_limited": {
+            "name": "Estado de límite de tasa"
+          },
+          "is_maintenance": {
+            "name": "Estado de mantenimiento"
+          },
+          "api_version": {
+            "name": "Versión de la API"
+          },
+          "endpoint_status": {
+            "name": "Estado del punto final"
+          },
+          "performance_metrics": {
+            "name": "Métricas de rendimiento"
+          },
+          "history_size": {
+            "name": "Tamaño del historial"
+          },
+          "uptime": {
+            "name": "Tiempo de actividad"
+          },
+          "total_tokens": {
+            "name": "Total de tokens"
+          },
+          "prompt_tokens": {
+            "name": "Tokens de indicación"
+          },
+          "completion_tokens": {
+            "name": "Tokens de compleción"
+          },
+          "successful_requests": {
+            "name": "Solicitudes exitosas"
+          },
+          "failed_requests": {
+            "name": "Solicitudes fallidas"
+          },
+          "average_latency": {
+            "name": "Latencia media"
+          },
+          "max_latency": {
+            "name": "Latencia máxima"
+          },
+          "min_latency": {
+            "name": "Latencia mínima"
+          }
+        }
+      }
+    }
+  }
+}

custom_components/ha_text_ai/translations/hi.json

@@ -0,0 +1,266 @@
+{
+  "config": {
+    "step": {
+      "provider": {
+        "title": "AI प्रदाता का चयन करें",
+        "description": "इस उदाहरण के लिए उपयोग करने के लिए AI सेवा प्रदाता चुनें।",
+        "data": {
+          "api_provider": "API प्रदाता",
+          "context_messages": "बनाए रखने के लिए संदर्भ संदेशों की संख्या (1-20)"
+        }
+      },
+      "user": {
+        "title": "HA टेक्स्ट AI उदाहरण को कॉन्फ़िगर करें",
+        "description": "अपने चयनित प्रदाता के साथ एक नया AI सहायक उदाहरण सेट करें।",
+        "data": {
+          "name": "उदाहरण का नाम (जैसे, 'GPT सहायक', 'क्लाउड सहायक')",
+          "api_key": "प्रमाणीकरण के लिए API कुंजी",
+          "model": "उपयोग करने के लिए AI मॉडल",
+          "temperature": "प्रतिक्रिया रचनात्मकता (0-2, कम = अधिक केंद्रित)",
+          "max_tokens": "अधिकतम प्रतिक्रिया लंबाई (1-4096 टोकन)",
+          "api_endpoint": "कस्टम API एंडपॉइंट URL (वैकल्पिक)",
+          "api_provider": "API प्रदाता",
+          "request_interval": "अनुरोधों के बीच न्यूनतम समय (0.1-60 सेकंड)",
+          "context_messages": "बनाए रखने के लिए संदर्भ संदेशों की संख्या (1-20)",
+          "max_history_size": "अधिकतम वार्तालाप इतिहास आकार (1-100)"
+        }
+      }
+    },
+    "error": {
+      "name_exists": "इस नाम का एक उदाहरण पहले से मौजूद है",
+      "invalid_name": "अमान्य उदाहरण नाम",
+      "invalid_auth": "प्रमाणीकरण विफल - अपनी API कुंजी जांचें",
+      "invalid_api_key": "अमान्य API कुंजी - कृपया अपनी क्रेडेंशियल सत्यापित करें",
+      "cannot_connect": "API सेवा से कनेक्ट करने में विफल",
+      "invalid_model": "चयनित मॉडल उपलब्ध नहीं है",
+      "rate_limit": "दर सीमा पार हो गई",
+      "context_length": "संदर्भ लंबाई पार हो गई",
+      "rate_limit_exceeded": "API दर सीमा पार हो गई",
+      "maintenance": "सेवा रखरखाव के अधीन है",
+      "invalid_response": "अमान्य API प्रतिक्रिया प्राप्त हुई",
+      "api_error": "API सेवा त्रुटि हुई",
+      "timeout": "अनुरोध समय समाप्त हो गया",
+      "invalid_instance": "अमान्य उदाहरण निर्दिष्ट किया गया",
+      "unknown": "अप्रत्याशित त्रुटि हुई",
+      "empty": "नाम खाली नहीं हो सकता",
+      "invalid_characters": "नाम में केवल अक्षर, संख्या, रिक्त स्थान, अंडरस्कोर और हाइफ़न हो सकते हैं",
+      "name_too_long": "नाम 50 वर्ण या उससे कम होना चाहिए"
+    }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "title": "उदाहरण सेटिंग्स अपडेट करें",
+        "description": "इस AI सहायक उदाहरण के लिए सेटिंग्स संशोधित करें।",
+        "data": {
+          "model": "AI मॉडल",
+          "temperature": "प्रतिक्रिया रचनात्मकता (0-2)",
+          "max_tokens": "अधिकतम प्रतिक्रिया लंबाई (1-4096)",
+          "request_interval": "न्यूनतम अनुरोध अंतराल (0.1-60 सेकंड)",
+          "context_messages": "संदर्भ में शामिल करने के लिए पिछले संदेशों की संख्या (1-20)",
+          "max_history_size": "अधिकतम वार्तालाप इतिहास आकार (1-100)"
+        }
+      }
+    }
+  },
+  "services": {
+    "ask_question": {
+      "name": "प्रश्न पूछें (HA टेक्स्ट AI)",
+      "description": "AI मॉडल को एक प्रश्न भेजें और एक विस्तृत प्रतिक्रिया प्राप्त करें। प्रतिक्रिया वार्तालाप इतिहास में संग्रहीत की जाएगी और बाद में पुनर्प्राप्त की जा सकती है।",
+      "fields": {
+        "instance": {
+          "name": "उदाहरण",
+          "description": "उपयोग करने के लिए HA टेक्स्ट AI उदाहरण का नाम"
+        },
+        "question": {
+          "name": "प्रश्न",
+          "description": "AI सहायक के लिए आपका प्रश्न या संकेत"
+        },
+        "context_messages": {
+          "name": "संदर्भ संदेश",
+          "description": "संदर्भ में शामिल करने के लिए पिछले संदेशों की संख्या (1-20)"
+        },
+        "system_prompt": {
+          "name": "सिस्टम प्रॉम्प्ट",
+          "description": "इस विशिष्ट प्रश्न के लिए संदर्भ सेट करने के लिए वैकल्पिक सिस्टम प्रॉम्प्ट"
+        },
+        "model": {
+          "name": "मॉडल",
+          "description": "उपयोग करने के लिए AI मॉडल का चयन करें (वैकल्पिक, डिफ़ॉल्ट सेटिंग को ओवरराइड करता है)"
+        },
+        "temperature": {
+          "name": "तापमान",
+          "description": "प्रतिक्रिया रचनात्मकता को नियंत्रित करता है (0.0-2.0)"
+        },
+        "max_tokens": {
+          "name": "अधिकतम टोकन",
+          "description": "प्रतिक्रिया की अधिकतम लंबाई (1-4096 टोकन)"
+        }
+      }
+    },
+    "clear_history": {
+      "name": "इतिहास साफ़ करें",
+      "description": "वार्तालाप इतिहास से सभी संग्रहीत प्रश्न और प्रतिक्रियाएँ हटाएँ",
+      "fields": {
+        "instance": {
+          "name": "उदाहरण",
+          "description": "इतिहास साफ़ करने के लिए HA टेक्स्ट AI उदाहरण का नाम"
+        }
+      }
+    },
+    "get_history": {
+      "name": "इतिहास प्राप्त करें",
+      "description": "वैकल्पिक फ़िल्टरिंग और सॉर्टिंग के साथ वार्तालाप इतिहास पुनर्प्राप्त करें",
+      "fields": {
+        "instance": {
+          "name": "उदाहरण",
+          "description": "इतिहास प्राप्त करने के लिए HA टेक्स्ट AI उदाहरण का नाम"
+        },
+        "limit": {
+          "name": "सीमा",
+          "description": "वापस करने के लिए वार्तालापों की संख्या (1-100)"
+        },
+        "filter_model": {
+          "name": "फ़िल्टर मॉडल",
+          "description": "विशिष्ट AI मॉडल द्वारा वार्तालापों को फ़िल्टर करें"
+        },
+        "start_date": {
+          "name": "प्रारंभ तिथि",
+          "description": "इस तिथि/समय से शुरू होने वाले वार्तालापों को फ़िल्टर करें"
+        },
+        "include_metadata": {
+          "name": "मेटाडेटा शामिल करें",
+          "description": "उपयोग किए गए टोकन, प्रतिक्रिया समय, आदि जैसी अतिरिक्त जानकारी शामिल करें।"
+        },
+        "sort_order": {
+          "name": "क्रमबद्ध करें",
+          "description": "परिणामों के लिए क्रमबद्ध क्रम (नवीनतम या सबसे पुराना पहले)"
+        }
+      }
+    },
+    "set_system_prompt": {
+      "name": "सिस्टम प्रॉम्प्ट सेट करें",
+      "description": "सभी भविष्य के वार्तालापों के लिए डिफ़ॉल्ट सिस्टम व्यवहार निर्देश सेट करें",
+      "fields": {
+        "instance": {
+          "name": "उदाहरण",
+          "description": "सिस्टम प्रॉम्प्ट सेट करने के लिए HA टेक्स्ट AI उदाहरण का नाम"
+        },
+        "prompt": {
+          "name": "सिस्टम प्रॉम्प्ट",
+          "description": "निर्देश जो परिभाषित करते हैं कि AI को कैसे व्यवहार करना चाहिए और जवाब देना चाहिए"
+        }
+      }
+    }
+  },
+  "entity": {
+    "sensor": {
+      "ha_text_ai": {
+        "name": "{name}",
+        "state": {
+          "ready": "तैयार",
+          "processing": "प्रक्रियाधीन",
+          "error": "त्रुटि",
+          "disconnected": "डिस्कनेक्टेड",
+          "rate_limited": "दर सीमित",
+          "maintenance": "रखरखाव",
+          "initializing": "आरंभिकरण",
+          "retrying": "पुनः प्रयास कर रहा है",
+          "queued": "कतारबद्ध"
+        },
+        "state_attributes": {
+          "question": {
+            "name": "अंतिम प्रश्न"
+          },
+          "response": {
+            "name": "अंतिम प्रतिक्रिया"
+          },
+          "model": {
+            "name": "वर्तमान मॉडल"
+          },
+          "temperature": {
+            "name": "तापमान"
+          },
+          "max_tokens": {
+            "name": "अधिकतम टोकन"
+          },
+          "system_prompt": {
+            "name": "सिस्टम प्रॉम्प्ट"
+          },
+          "response_time": {
+            "name": "अंतिम प्रतिक्रिया समय"
+          },
+          "total_responses": {
+            "name": "कुल प्रतिक्रियाएँ"
+          },
+          "error_count": {
+            "name": "त्रुटि गणना"
+          },
+          "last_error": {
+            "name": "अंतिम त्रुटि"
+          },
+          "api_status": {
+            "name": "API स्थिति"
+          },
+          "tokens_used": {
+            "name": "कुल टोकन उपयोग किए गए"
+          },
+          "average_response_time": {
+            "name": "औसत प्रतिक्रिया समय"
+          },
+          "last_request_time": {
+            "name": "अंतिम अनुरोध समय"
+          },
+          "is_processing": {
+            "name": "प्रसंस्करण स्थिति"
+          },
+          "is_rate_limited": {
+            "name": "दर सीमित स्थिति"
+          },
+          "is_maintenance": {
+            "name": "रखरखाव स्थिति"
+          },
+          "api_version": {
+            "name": "API संस्करण"
+          },
+          "endpoint_status": {
+            "name": "एंडपॉइंट स्थिति"
+          },
+          "performance_metrics": {
+            "name": "प्रदर्शन मेट्रिक्स"
+          },
+          "history_size": {
+            "name": "इतिहास का आकार"
+          },
+          "uptime": {
+            "name": "अपटाइम"
+          },
+          "total_tokens": {
+            "name": "कुल टोकन"
+          },
+          "prompt_tokens": {
+            "name": "प्रॉम्प्ट टोकन"
+          },
+          "completion_tokens": {
+            "name": "पूर्ण टोकन"
+          },
+          "successful_requests": {
+            "name": "सफल अनुरोध"
+          },
+          "failed_requests": {
+            "name": "असफल अनुरोध"
+          },
+          "average_latency": {
+            "name": "औसत विलंबता"
+          },
+          "max_latency": {
+            "name": "अधिकतम विलंबता"
+          },
+          "min_latency": {
+            "name": "न्यूनतम विलंबता"
+          }
+        }
+      }
+    }
+  }
+}

custom_components/ha_text_ai/translations/it.json

@@ -0,0 +1,266 @@
+{
+  "config": {
+    "step": {
+      "provider": {
+        "title": "Seleziona Provider AI",
+        "description": "Scegli quale provider di servizio AI utilizzare per questa istanza.",
+        "data": {
+          "api_provider": "Provider API",
+          "context_messages": "Numero di messaggi di contesto da conservare (1-20)"
+        }
+      },
+      "user": {
+        "title": "Configura Istanza HA Text AI",
+        "description": "Configura una nuova istanza di assistente AI con il provider selezionato.",
+        "data": {
+          "name": "Nome dell'istanza (es. 'Assistente GPT', 'Aiutante Claude')",
+          "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)",
+          "api_endpoint": "URL endpoint API personalizzato (opzionale)",
+          "api_provider": "Provider API",
+          "request_interval": "Tempo minimo tra le richieste (0,1-60 secondi)",
+          "context_messages": "Numero di messaggi di contesto da conservare (1-20)",
+          "max_history_size": "Dimensione massima della cronologia delle conversazioni (1-100)"
+        }
+      }
+    },
+    "error": {
+      "name_exists": "Un'istanza con questo nome esiste già",
+      "invalid_name": "Nome dell'istanza non valido",
+      "invalid_auth": "Autenticazione fallita - controlla la tua chiave API",
+      "invalid_api_key": "Chiave API non valida - verifica le tue credenziali",
+      "cannot_connect": "Impossibile connettersi al servizio API",
+      "invalid_model": "Il modello selezionato non è disponibile",
+      "rate_limit": "Limite di velocità superato",
+      "context_length": "Lunghezza del contesto superata",
+      "rate_limit_exceeded": "Limite di velocità API superato",
+      "maintenance": "Il servizio è in manutenzione",
+      "invalid_response": "Risposta API non valida ricevuta",
+      "api_error": "Si è verificato un errore del servizio API",
+      "timeout": "Richiesta scaduta",
+      "invalid_instance": "Istanza non valida specificata",
+      "unknown": "Si è verificato un errore imprevisto",
+      "empty": "Il nome non può essere vuoto",
+      "invalid_characters": "Il nome può contenere solo lettere, numeri, spazi, trattini bassi e trattini",
+      "name_too_long": "Il nome non può superare i 50 caratteri"
+    }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "title": "Aggiorna Impostazioni Istanza",
+        "description": "Modifica le impostazioni per questa istanza di assistente AI.",
+        "data": {
+          "model": "Modello AI",
+          "temperature": "Creatività della risposta (0-2)",
+          "max_tokens": "Lunghezza massima della risposta (1-4096)",
+          "request_interval": "Intervallo minimo tra le richieste (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)"
+        }
+      }
+    }
+  },
+  "services": {
+    "ask_question": {
+      "name": "Fai una Domanda (HA Text AI)",
+      "description": "Invia una domanda al modello AI e ricevi una risposta dettagliata. La risposta verrà memorizzata nella cronologia delle conversazioni e potrà essere recuperata in seguito.",
+      "fields": {
+        "instance": {
+          "name": "Istanza",
+          "description": "Nome dell'istanza HA Text AI da utilizzare"
+        },
+        "question": {
+          "name": "Domanda",
+          "description": "La tua domanda o prompt per l'assistente AI"
+        },
+        "context_messages": {
+          "name": "Messaggi di Contesto",
+          "description": "Numero di messaggi precedenti da includere nel contesto (1-20)"
+        },
+        "system_prompt": {
+          "name": "Prompt di Sistema",
+          "description": "Prompt di sistema opzionale per impostare il contesto per questa specifica domanda"
+        },
+        "model": {
+          "name": "Modello",
+          "description": "Seleziona il modello AI da utilizzare (opzionale, sovrascrive l'impostazione predefinita)"
+        },
+        "temperature": {
+          "name": "Temperatura",
+          "description": "Controlla la creatività della risposta (0.0-2.0)"
+        },
+        "max_tokens": {
+          "name": "Max Token",
+          "description": "Lunghezza massima della risposta (1-4096 token)"
+        }
+      }
+    },
+    "clear_history": {
+      "name": "Cancella Cronologia",
+      "description": "Elimina tutte le domande e le risposte memorizzate dalla cronologia delle conversazioni",
+      "fields": {
+        "instance": {
+          "name": "Istanza",
+          "description": "Nome dell'istanza HA Text AI per cui cancellare la cronologia"
+        }
+      }
+    },
+    "get_history": {
+      "name": "Ottieni Cronologia",
+      "description": "Recupera la cronologia delle conversazioni con filtro e ordinamento opzionali",
+      "fields": {
+        "instance": {
+          "name": "Istanza",
+          "description": "Nome dell'istanza HA Text AI da cui ottenere la cronologia"
+        },
+        "limit": {
+          "name": "Limite",
+          "description": "Numero di conversazioni da restituire (1-100)"
+        },
+        "filter_model": {
+          "name": "Filtro Modello",
+          "description": "Filtra le conversazioni per specifico modello AI"
+        },
+        "start_date": {
+          "name": "Data di Inizio",
+          "description": "Filtra le conversazioni a partire da questa data/ora"
+        },
+        "include_metadata": {
+          "name": "Includi Metadati",
+          "description": "Includi informazioni aggiuntive come token utilizzati, tempo di risposta, ecc."
+        },
+        "sort_order": {
+          "name": "Ordine di Ordinamento",
+          "description": "Ordine di ordinamento per i risultati (più recente o più vecchio per primo)"
+        }
+      }
+    },
+    "set_system_prompt": {
+      "name": "Imposta Prompt di Sistema",
+      "description": "Imposta le istruzioni di comportamento predefinite del sistema per tutte le future conversazioni",
+      "fields": {
+        "instance": {
+          "name": "Istanza",
+          "description": "Nome dell'istanza HA Text AI per cui impostare il prompt di sistema"
+        },
+        "prompt": {
+          "name": "Prompt di Sistema",
+          "description": "Istruzioni che definiscono come l'IA dovrebbe comportarsi e rispondere"
+        }
+      }
+    }
+  },
+  "entity": {
+    "sensor": {
+      "ha_text_ai": {
+        "name": "{name}",
+        "state": {
+          "ready": "Pronto",
+          "processing": "In elaborazione",
+          "error": "Errore",
+          "disconnected": "Disconnesso",
+          "rate_limited": "Limite di Velocità Raggiunto",
+          "maintenance": "Manutenzione",
+          "initializing": "Inizializzazione",
+          "retrying": "Riprovando",
+          "queued": "In coda"
+        },
+        "state_attributes": {
+          "question": {
+            "name": "Ultima Domanda"
+          },
+          "response": {
+            "name": "Ultima Risposta"
+          },
+          "model": {
+            "name": "Modello Attuale"
+          },
+          "temperature": {
+            "name": "Temperatura"
+          },
+          "max_tokens": {
+            "name": "Max Token"
+          },
+          "system_prompt": {
+            "name": "Prompt di Sistema"
+          },
+          "response_time": {
+            "name": "Tempo di Risposta Ultima"
+          },
+          "total_responses": {
+            "name": "Totale Risposte"
+          },
+          "error_count": {
+            "name": "Numero di Errori"
+          },
+          "last_error": {
+            "name": "Ultimo Errore"
+          },
+          "api_status": {
+            "name": "Stato API"
+          },
+          "tokens_used": {
+            "name": "Totale Token Utilizzati"
+          },
+          "average_response_time": {
+            "name": "Tempo di Risposta Medio"
+          },
+          "last_request_time": {
+            "name": "Tempo Ultima Richiesta"
+          },
+          "is_processing": {
+            "name": "Stato Elaborazione"
+          },
+          "is_rate_limited": {
+            "name": "Stato Limite Velocità"
+          },
+          "is_maintenance": {
+            "name": "Stato Manutenzione"
+          },
+          "api_version": {
+            "name": "Versione API"
+          },
+          "endpoint_status": {
+            "name": "Stato Endpoint"
+          },
+          "performance_metrics": {
+            "name": "Metriche Prestazioni"
+          },
+          "history_size": {
+            "name": "Dimensione Cronologia"
+          },
+          "uptime": {
+            "name": "Tempo di Funzionamento"
+          },
+          "total_tokens": {
+            "name": "Totale Token"
+          },
+          "prompt_tokens": {
+            "name": "Token Prompt"
+          },
+          "completion_tokens": {
+            "name": "Token Completamento"
+          },
+          "successful_requests": {
+            "name": "Richieste Riuscite"
+          },
+          "failed_requests": {
+            "name": "Richieste Fallite"
+          },
+          "average_latency": {
+            "name": "Latency Media"
+          },
+          "max_latency": {
+            "name": "Latency Massima"
+          },
+          "min_latency": {
+            "name": "Latency Minima"
+            }
+          }
+        }
+      }
+    }
+  }

custom_components/ha_text_ai/translations/ru.json

@@ -1,260 +1,266 @@
 {
-    "config": {
-        "step": {
-            "provider": {
-                "title": "Выбор провайдера ИИ",
-                "description": "Выберите сервис ИИ для этого экземпляра",
-                "data": {
-                    "api_provider": "Провайдер API",
-                    "context_messages": "Количество сообщений в контексте (1-20)"  
-                }
-            },
-            "user": {
-                "title": "Настройка экземпляра HA Text AI",
-                "description": "Настройте нового помощника ИИ с выбранным провайдером",
-                "data": {
-                    "name": "Название экземпляра (например, 'GPT Помощник', 'Claude Ассистент')",
-                    "api_key": "API-ключ для аутентификации",
-                    "model": "Модель ИИ для использования",
-                    "temperature": "Креативность ответов (0-2, меньше = более сфокусированно)",
-                    "max_tokens": "Максимальная длина ответа (1-4096 токенов)",
-                    "api_endpoint": "Пользовательский URL-адрес API (необязательно)",
-                    "request_interval": "Минимальный интервал между запросами (0.1-60 секунд)",
-                    "context_messages": "Количество сохраняемых контекстных сообщений (1-20)"
-                }
-            }
-        },
-        "error": {
-            "name_exists": "Экземпляр с таким именем уже существует",
-            "invalid_name": "Некорректное имя экземпляра",
-            "invalid_auth": "Ошибка аутентификации - проверьте API-ключ",
-            "invalid_api_key": "Неверный API-ключ - проверьте учетные данные",
-            "cannot_connect": "Не удалось подключиться к сервису API",
-            "invalid_model": "Выбранная модель недоступна",
-            "rate_limit": "Превышен лимит запросов",
-            "context_length": "Превышена длина контекста",
-            "rate_limit_exceeded": "Превышен лимит API",
-            "maintenance": "Сервис на техническом обслуживании",
-            "invalid_response": "Получен некорректный ответ API",
-            "api_error": "Произошла ошибка сервиса API",
-            "timeout": "Время ожидания истекло",
-            "invalid_instance": "Указан неверный экземпляр",
-            "unknown": "Произошла непредвиденная ошибка"
+  "config": {
+    "step": {
+      "provider": {
+        "title": "Выбор поставщика ИИ",
+        "description": "Выберите поставщика услуг ИИ для этой инстанции.",
+        "data": {
+          "api_provider": "Поставщик API",
+          "context_messages": "Количество контекстных сообщений для сохранения (1-20)"
         }
+      },
+      "user": {
+        "title": "Настройка инстанции HA Text AI",
+        "description": "Настройте новую инстанцию помощника ИИ с выбранным вами поставщиком.",
+        "data": {
+          "name": "Имя инстанции (например, 'GPT Assistant', 'Claude Helper')",
+          "api_key": "API-ключ для аутентификации",
+          "model": "Используемая модель ИИ",
+          "temperature": "Креативность ответа (0-2, чем ниже, тем больше фокусировки)",
+          "max_tokens": "Максимальная длина ответа (1-4096 токенов)",
+          "api_endpoint": "Пользовательский URL-адрес конечной точки API (необязательно)",
+          "api_provider": "Поставщик API",
+          "request_interval": "Минимальное время между запросами (0,1-60 секунд)",
+          "context_messages": "Количество контекстных сообщений для сохранения (1-20)",
+          "max_history_size": "Максимальный размер истории разговора (1-100)"
+        }
+      }
     },
-    "options": {
-        "step": {
-            "init": {
-                "title": "Обновление настроек экземпляра",
-                "description": "Измените настройки для этого помощника ИИ",
-                "data": {
-                    "model": "Модель ИИ",
-                    "temperature": "Креативность ответов (0-2)",
-                    "max_tokens": "Максимальная длина ответа (1-4096)",
-                    "request_interval": "Минимальный интервал запросов (0.1-60 секунд)",
-                    "context_messages": "Количество предыдущих сообщений для включения в контекст (1-20)"
-                }
-            }
-        }
-    },
-    "services": {
-        "ask_question": {
-            "name": "Задать вопрос (HA Text AI)",
-            "description": "Отправьте вопрос модели ИИ и получите подробный ответ. Ответ будет сохранен в истории беседы и может быть извлечен позже.",
-            "fields": {
-                "instance": {
-                    "name": "Экземпляр",
-                    "description": "Название экземпляра HA Text AI для использования"
-                },
-                "question": {
-                    "name": "Вопрос",
-                    "description": "Ваш вопрос или запрос помощнику ИИ"
-                },
-                "context_messages": {
-                    "name": "Контекстные сообщения",
-                    "description": "Количество предыдущих сообщений для включения в контекст (1-20)"
-                },
-                "system_prompt": {
-                    "name": "Системный промпт",
-                    "description": "Необязательный системный промпт для установки контекста для этого конкретного вопроса"
-                },
-                "model": {
-                    "name": "Модель",
-                    "description": "Выберите модель ИИ (необязательно, переопределяет настройки по умолчанию)"
-                },
-                "temperature": {
-                    "name": "Температура",
-                    "description": "Управляет креативностью ответа (0.0-2.0)"
-                },
-                "max_tokens": {
-                    "name": "Максимальное количество токенов",
-                    "description": "Максимальная длина ответа (1-4096 токенов)"
-                }
-            }
-        },
-        "clear_history": {
-            "name": "Очистить историю",
-            "description": "Удалить все сохраненные вопросы и ответы из истории беседы",
-            "fields": {
-                "instance": {
-                    "name": "Экземпляр",
-                    "description": "Название экземпляра HA Text AI для очистки истории"
-                }
-            }
-        },
-        "get_history": {
-            "name": "Получить историю",
-            "description": "Получить историю беседы с дополнительной фильтрацией и сортировкой",
-            "fields": {
-                "instance": {
-                    "name": "Экземпляр",
-                    "description": "Название экземпляра HA Text AI для получения истории"
-                },
-                "limit": {
-                    "name": "Лимит",
-                    "description": "Количество возвращаемых бесед (1-100)"
-                },
-                "filter_model": {
-                    "name": "Фильтр модели",
-                    "description": "Фильтрация бесед по конкретной модели ИИ"
-                },
-                "start_date": {
-                    "name": "Начальная дата",
-                    "description": "Фильтрация бесед, начиная с указанной даты/времени"
-                },
-                "include_metadata": {
-                    "name": "Включить метаданные",
-                    "description": "Включить дополнительную информацию, например, использованные токены, время ответа и т.д."
-                },
-                "sort_order": {
-                    "name": "Порядок сортировки",
-                    "description": "Порядок результатов (сначала новые или старые)"
-                }
-            }
-        },
-        "set_system_prompt": {
-            "name": "Установить системный промпт",
-            "description": "Установить инструкции по умолчанию для поведения ИИ во всех будущих разговорах",
-            "fields": {
-                "instance": {
-                    "name": "Экземпляр",
-                    "description": "Название экземпляра HA Text AI для установки системного промпта"
-                },
-                "prompt": {
-                    "name": "Системный промпт",
-                    "description": "Инструкции, определяющие, как ИИ должен вести себя и отвечать"
-                }
-            }
-        }
-    },
-    "entity": {
-        "sensor": {
-            "ha_text_ai": {
-                "name": "{name}",
-                "state": {
-                    "ready": "Готов",
-                    "processing": "Обработка",
-                    "error": "Ошибка",
-                    "disconnected": "Отключен",
-                    "rate_limited": "Лимит запросов",
-                    "maintenance": "Техническое обслуживание",
-                    "initializing": "Инициализация",
-                    "retrying": "Повторная попытка",
-                    "queued": "В очереди"
-                },
-                "state_attributes": {
-                    "question": {
-                        "name": "Последний вопрос"
-                    },
-                    "response": {
-                        "name": "Последний ответ"
-                    },
-                    "model": {
-                        "name": "Текущая модель"
-                    },
-                    "temperature": {
-                        "name": "Температура"
-                    },
-                    "max_tokens": {
-                        "name": "Максимальное количество токенов"
-                    },
-                    "system_prompt": {
-                        "name": "Системный промпт"
-                    },
-                    "response_time": {
-                        "name": "Время последнего ответа"
-                    },
-                    "total_responses": {
-                        "name": "Всего ответов"
-                    },
-                    "error_count": {
-                        "name": "Количество ошибок"
-                    },
-                    "last_error": {
-                        "name": "Последняя ошибка"
-                    },
-                    "api_status": {
-                        "name": "Статус API"
-                    },
-                    "tokens_used": {
-                        "name": "Всего использовано токенов"
-                    },
-                    "average_response_time": {
-                        "name": "Среднее время ответа"
-                    },
-                    "last_request_time": {
-                        "name": "Время последнего запроса"
-                    },
-                    "is_processing": {
-                        "name": "Статус обработки"
-                    },
-                    "is_rate_limited": {
-                        "name": "Статус лимита запросов"
-                    },
-                    "is_maintenance": {
-                        "name": "Статус обслуживания"
-                    },
-                    "api_version": {
-                        "name": "Версия API"
-                    },
-                    "endpoint_status": {
-                        "name": "Статус эндпоинта"
-                    },
-                    "performance_metrics": {
-                        "name": "Показатели производительности"
-                    },
-                    "history_size": {
-                        "name": "Размер истории"
-                    },
-                    "uptime": {
-                        "name": "Время работы"
-                    },
-                    "total_tokens": {
-                        "name": "Всего токенов"
-                    },
-                    "prompt_tokens": {
-                        "name": "Токены промпта"
-                    },
-                    "completion_tokens": {
-                        "name": "Токены завершения"
-                    },
-                    "successful_requests": {
-                        "name": "Успешные запросы"
-                    },
-                    "failed_requests": {
-                        "name": "Неудачные запросы"
-                    },
-                    "average_latency": {
-                        "name": "Средняя задержка"
-                    },
-                    "max_latency": {
-                        "name": "Максимальная задержка"
-                    },
-                    "min_latency": {
-                        "name": "Минимальная задержка"
-                    }
-                }
-            }
-        }
+    "error": {
+      "name_exists": "Инстанция с таким именем уже существует",
+      "invalid_name": "Некорректное имя инстанции",
+      "invalid_auth": "Аутентификация не удалась - проверьте ваш API-ключ",
+      "invalid_api_key": "Неверный API-ключ - проверьте ваши учетные данные",
+      "cannot_connect": "Не удалось подключиться к службе API",
+      "invalid_model": "Выбранная модель недоступна",
+      "rate_limit": "Превышен лимит запросов",
+      "context_length": "Превышена длина контекста",
+      "rate_limit_exceeded": "Превышен лимит запросов API",
+      "maintenance": "Сервис находится на техническом обслуживании",
+      "invalid_response": "Получен неверный ответ API",
+      "api_error": "Произошла ошибка службы API",
+      "timeout": "Запрос превысил время ожидания",
+      "invalid_instance": "Указана неверная инстанция",
+      "unknown": "Произошла непредвиденная ошибка",
+      "empty": "Имя не может быть пустым",
+      "invalid_characters": "Имя может содержать только буквы, цифры, пробелы, подчеркивания и дефисы",
+      "name_too_long": "Имя должно быть не более 50 символов"
     }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "title": "Обновление настроек инстанции",
+        "description": "Измените настройки для этой инстанции помощника ИИ.",
+        "data": {
+          "model": "Модель ИИ",
+          "temperature": "Креативность ответа (0-2)",
+          "max_tokens": "Максимальная длина ответа (1-4096)",
+          "request_interval": "Минимальный интервал между запросами (0,1-60 секунд)",
+          "context_messages": "Количество предыдущих сообщений для включения в контекст (1-20)",
+          "max_history_size": "Максимальный размер истории разговора (1-100)"
+        }
+      }
+    }
+  },
+  "services": {
+    "ask_question": {
+      "name": "Задать вопрос (HA Text AI)",
+      "description": "Отправьте вопрос модели ИИ и получите подробный ответ. Ответ будет сохранен в истории разговора и может быть извлечен позже.",
+      "fields": {
+        "instance": {
+          "name": "Инстанция",
+          "description": "Имя используемой инстанции HA Text AI"
+        },
+        "question": {
+          "name": "Вопрос",
+          "description": "Ваш вопрос или запрос к помощнику ИИ"
+        },
+        "context_messages": {
+          "name": "Контекстные сообщения",
+          "description": "Количество предыдущих сообщений для включения в контекст (1-20)"
+        },
+        "system_prompt": {
+          "name": "Системный запрос",
+          "description": "Необязательный системный запрос для установки контекста для этого конкретного вопроса"
+        },
+        "model": {
+          "name": "Модель",
+          "description": "Выберите модель ИИ для использования (необязательно, переопределяет настройку по умолчанию)"
+        },
+        "temperature": {
+          "name": "Температура",
+          "description": "Управляет креативностью ответа (0.0-2.0)"
+        },
+        "max_tokens": {
+          "name": "Макс. токенов",
+          "description": "Максимальная длина ответа (1-4096 токенов)"
+        }
+      }
+    },
+    "clear_history": {
+      "name": "Очистить историю",
+      "description": "Удалить все сохраненные вопросы и ответы из истории разговора",
+      "fields": {
+        "instance": {
+          "name": "Инстанция",
+          "description": "Имя инстанции HA Text AI, для которой нужно очистить историю"
+        }
+      }
+    },
+    "get_history": {
+      "name": "Получить историю",
+      "description": "Извлечь историю разговора с возможностью фильтрации и сортировки",
+      "fields": {
+        "instance": {
+          "name": "Инстанция",
+          "description": "Имя инстанции HA Text AI, из которой нужно получить историю"
+        },
+        "limit": {
+          "name": "Лимит",
+          "description": "Количество разговоров для возврата (1-100)"
+        },
+        "filter_model": {
+          "name": "Фильтр модели",
+          "description": "Фильтрация разговоров по определенной модели ИИ"
+        },
+        "start_date": {
+          "name": "Дата начала",
+          "description": "Фильтрация разговоров, начиная с этой даты/времени"
+        },
+        "include_metadata": {
+          "name": "Включить метаданные",
+          "description": "Включить дополнительную информацию, такую как использованные токены, время ответа и т.д."
+        },
+        "sort_order": {
+          "name": "Порядок сортировки",
+          "description": "Порядок сортировки результатов (самые новые или самые старые)"
+        }
+      }
+    },
+    "set_system_prompt": {
+      "name": "Установить системный запрос",
+      "description": "Установить инструкции по умолчанию для поведения системы для всех будущих разговоров",
+      "fields": {
+        "instance": {
+          "name": "Инстанция",
+          "description": "Имя инстанции HA Text AI, для которой нужно установить системный запрос"
+        },
+        "prompt": {
+          "name": "Системный запрос",
+          "description": "Инструкции, определяющие, как ИИ должен себя вести и отвечать"
+        }
+      }
+    }
+  },
+  "entity": {
+    "sensor": {
+      "ha_text_ai": {
+        "name": "{name}",
+        "state": {
+          "ready": "Готов",
+          "processing": "Обработка",
+          "error": "Ошибка",
+          "disconnected": "Отключен",
+          "rate_limited": "Лимит запросов",
+          "maintenance": "Техническое обслуживание",
+          "initializing": "Инициализация",
+          "retrying": "Повторная попытка",
+          "queued": "В очереди"
+        },
+        "state_attributes": {
+          "question": {
+            "name": "Последний вопрос"
+          },
+          "response": {
+            "name": "Последний ответ"
+          },
+          "model": {
+            "name": "Текущая модель"
+          },
+          "temperature": {
+            "name": "Температура"
+          },
+          "max_tokens": {
+            "name": "Макс. токенов"
+          },
+          "system_prompt": {
+            "name": "Системный запрос"
+          },
+          "response_time": {
+            "name": "Время последнего ответа"
+          },
+          "total_responses": {
+            "name": "Всего ответов"
+          },
+          "error_count": {
+            "name": "Количество ошибок"
+          },
+          "last_error": {
+            "name": "Последняя ошибка"
+          },
+          "api_status": {
+            "name": "Статус API"
+          },
+          "tokens_used": {
+            "name": "Использовано токенов всего"
+          },
+          "average_response_time": {
+            "name": "Среднее время ответа"
+          },
+          "last_request_time": {
+            "name": "Время последнего запроса"
+          },
+          "is_processing": {
+            "name": "Статус обработки"
+          },
+          "is_rate_limited": {
+            "name": "Статус ограничения запросов"
+          },
+          "is_maintenance": {
+            "name": "Статус технического обслуживания"
+          },
+          "api_version": {
+            "name": "Версия API"
+          },
+          "endpoint_status": {
+            "name": "Статус конечной точки"
+          },
+          "performance_metrics": {
+            "name": "Метрики производительности"
+          },
+          "history_size": {
+            "name": "Размер истории"
+          },
+          "uptime": {
+            "name": "Время работы"
+          },
+          "total_tokens": {
+            "name": "Всего токенов"
+          },
+          "prompt_tokens": {
+            "name": "Токены запроса"
+          },
+          "completion_tokens": {
+            "name": "Токены завершения"
+          },
+          "successful_requests": {
+            "name": "Успешных запросов"
+          },
+          "failed_requests": {
+            "name": "Неудачных запросов"
+          },
+          "average_latency": {
+            "name": "Средняя задержка"
+          },
+          "max_latency": {
+            "name": "Максимальная задержка"
+          },
+          "min_latency": {
+            "name": "Минимальная задержка"
+          }
+        }
+      }
+    }
+  }
 }

custom_components/ha_text_ai/translations/sr.json

@@ -0,0 +1,266 @@
+{
+  "config": {
+    "step": {
+      "provider": {
+        "title": "Изаберите добављача вештачке интелигенције",
+        "description": "Изаберите добављача услуга вештачке интелигенције који ћете користити за ову инстанцу.",
+        "data": {
+          "api_provider": "Добављач API-ја",
+          "context_messages": "Број порука контекста које треба задржати (1-20)"
+        }
+      },
+      "user": {
+        "title": "Конфигуришите инстанцу HA Text AI",
+        "description": "Поставите нову инстанцу асистента вештачке интелигенције са изабраним добављачем.",
+        "data": {
+          "name": "Назив инстанце (нпр. 'GPT Assistant', 'Claude Helper')",
+          "api_key": "API кључ за аутентификацију",
+          "model": "Модел вештачке интелигенције који треба користити",
+          "temperature": "Креативност одговора (0-2, нижа = више фокусирана)",
+          "max_tokens": "Максимална дужина одговора (1-4096 токена)",
+          "api_endpoint": "Прилагођени URL завршног тачка API-ја (опционо)",
+          "api_provider": "Добављач API-ја",
+          "request_interval": "Минимално време између захтева (0.1-60 секунди)",
+          "context_messages": "Број порука контекста које треба задржати (1-20)",
+          "max_history_size": "Максимална величина историје разговора (1-100)"
+        }
+      }
+    },
+    "error": {
+      "name_exists": "Инстанца са овим називом већ постоји",
+      "invalid_name": "Неважећи назив инстанце",
+      "invalid_auth": "Аутентификација није успела - проверите свој API кључ",
+      "invalid_api_key": "Неважећи API кључ - проверите своје податке о верификацији",
+      "cannot_connect": "Није могуће успоставити везу са услугом API-ја",
+      "invalid_model": "Изабрани модел није доступан",
+      "rate_limit": "Прекорачен је лимит стопе",
+      "context_length": "Прекорачена је дужина контекста",
+      "rate_limit_exceeded": "Прекорачен је лимит стопе API-ја",
+      "maintenance": "Услуга је у фази одржавања",
+      "invalid_response": "Примљен је неважећи одговор API-ја",
+      "api_error": "Догодила се грешка у услузи API-ја",
+      "timeout": "Захтев је истекао",
+      "invalid_instance": "Наведена је неважећа инстанца",
+      "unknown": "Догодила се неочекивана грешка",
+      "empty": "Назив не може бити празан",
+      "invalid_characters": "Назив може да садржи само слова, бројеве, размаке, цртице и цртице",
+      "name_too_long": "Назив мора бити 50 карактера или мање"
+    }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "title": "Ажурирајте подешавања инстанце",
+        "description": "Измените подешавања за ову инстанцу асистента вештачке интелигенције.",
+        "data": {
+          "model": "Модел вештачке интелигенције",
+          "temperature": "Креативност одговора (0-2)",
+          "max_tokens": "Максимална дужина одговора (1-4096)",
+          "request_interval": "Минимални интервал захтева (0.1-60 секунди)",
+          "context_messages": "Број претходних порука које треба укључити у контекст (1-20)",
+          "max_history_size": "Максимална величина историје разговора (1-100)"
+        }
+      }
+    }
+  },
+  "services": {
+    "ask_question": {
+      "name": "Поставите питање (HA Text AI)",
+      "description": "Пошаљите питање моделу вештачке интелигенције и добијте детаљан одговор. Одговор ће бити сачуван у историји разговора и може се касније преузети.",
+      "fields": {
+        "instance": {
+          "name": "Инстанца",
+          "description": "Назив инстанце HA Text AI коју треба користити"
+        },
+        "question": {
+          "name": "Питање",
+          "description": "Ваше питање или наговештај за асистента вештачке интелигенције"
+        },
+        "context_messages": {
+          "name": "Поруке контекста",
+          "description": "Број претходних порука које треба укључити у контекст (1-20)"
+        },
+        "system_prompt": {
+          "name": "Системски наговештај",
+          "description": "Опциони системски наговештај за постављање контекста за ово одређено питање"
+        },
+        "model": {
+          "name": "Модел",
+          "description": "Изаберите модел вештачке интелигенције који треба користити (опционо, преклапа подразумевано подешавање)"
+        },
+        "temperature": {
+          "name": "Температура",
+          "description": "Контролише креативност одговора (0.0-2.0)"
+        },
+        "max_tokens": {
+          "name": "Макс. токени",
+          "description": "Максимална дужина одговора (1-4096 токена)"
+        }
+      }
+    },
+    "clear_history": {
+      "name": "Обриши историју",
+      "description": "Обришите сва сачувана питања и одговоре из историје разговора",
+      "fields": {
+        "instance": {
+          "name": "Инстанца",
+          "description": "Назив инстанце HA Text AI за коју треба очистити историју"
+        }
+      }
+    },
+    "get_history": {
+      "name": "Добиј историју",
+      "description": "Преузмите историју разговора са опционом филтрацијом и сортирањем",
+      "fields": {
+        "instance": {
+          "name": "Инстанца",
+          "description": "Назив инстанце HA Text AI из које треба добити историју"
+        },
+        "limit": {
+          "name": "Лимит",
+          "description": "Број разговора који треба вратити (1-100)"
+        },
+        "filter_model": {
+          "name": "Филтер модела",
+          "description": "Филтрирајте разговоре по одређеном моделу вештачке интелигенције"
+        },
+        "start_date": {
+          "name": "Почетни датум",
+          "description": "Филтрирајте разговоре почев од овог датума/времена"
+        },
+        "include_metadata": {
+          "name": "Укључи метаподатке",
+          "description": "Укључите додатне информације попут коришћених токена, времена одговора и слично."
+        },
+        "sort_order": {
+          "name": "Редослед сортирања",
+          "description": "Редослед сортирања за резултате (најновији или најстарији прво)"
+        }
+      }
+    },
+    "set_system_prompt": {
+      "name": "Поставите системски наговештај",
+      "description": "Поставите подразумевана упутства за понашање система за све будуће разговоре",
+      "fields": {
+        "instance": {
+          "name": "Инстанца",
+          "description": "Назив инстанце HA Text AI за коју треба поставити системски наговештај"
+        },
+        "prompt": {
+          "name": "Системски наговештај",
+          "description": "Упутства која дефинишу како би се вештачка интелигенција требала понашати и одговарати"
+        }
+      }
+    }
+  },
+  "entity": {
+    "sensor": {
+      "ha_text_ai": {
+        "name": "{name}",
+        "state": {
+          "ready": "Спремно",
+          "processing": "Обрада",
+          "error": "Грешка",
+          "disconnected": "Искључено",
+          "rate_limited": "Лимит стопе",
+          "maintenance": "Одржавање",
+          "initializing": "Иницијализација",
+          "retrying": "Понављање",
+          "queued": "У реду чекања"
+        },
+        "state_attributes": {
+          "question": {
+            "name": "Последње питање"
+          },
+          "response": {
+            "name": "Последњи одговор"
+          },
+          "model": {
+            "name": "Тренутни модел"
+          },
+          "temperature": {
+            "name": "Температура"
+          },
+          "max_tokens": {
+            "name": "Макс. токени"
+          },
+          "system_prompt": {
+            "name": "Системски наговештај"
+          },
+          "response_time": {
+            "name": "Време последњег одговора"
+          },
+          "total_responses": {
+            "name": "Укупан број одговора"
+          },
+          "error_count": {
+            "name": "Број грешака"
+          },
+          "last_error": {
+            "name": "Последња грешка"
+          },
+          "api_status": {
+            "name": "Статус API-ја"
+          },
+          "tokens_used": {
+            "name": "Укупно коришћених токена"
+          },
+          "average_response_time": {
+            "name": "Просечно време одговора"
+          },
+          "last_request_time": {
+            "name": "Време последњег захтева"
+          },
+          "is_processing": {
+            "name": "Статус обраде"
+          },
+          "is_rate_limited": {
+            "name": "Статус ограничења стопе"
+          },
+          "is_maintenance": {
+            "name": "Статус одржавања"
+          },
+          "api_version": {
+            "name": "Верзија API-ја"
+          },
+          "endpoint_status": {
+            "name": "Статус завршне тачке"
+          },
+          "performance_metrics": {
+            "name": "Метрике перформанси"
+          },
+          "history_size": {
+            "name": "Величина историје"
+          },
+          "uptime": {
+            "name": "Време рада"
+          },
+          "total_tokens": {
+            "name": "Укупан број токена"
+          },
+          "prompt_tokens": {
+            "name": "Токени наговештаја"
+          },
+          "completion_tokens": {
+            "name": "Токени довршетака"
+          },
+          "successful_requests": {
+            "name": "Успешни захтеви"
+          },
+          "failed_requests": {
+            "name": "Неуспешни захтеви"
+          },
+          "average_latency": {
+            "name": "Просечна латенција"
+          },
+          "max_latency": {
+            "name": "Максимална латенција"
+          },
+          "min_latency": {
+            "name": "Минимална латенција"
+          }
+        }
+      }
+    }
+  }
+}

custom_components/ha_text_ai/translations/zh.json

@@ -0,0 +1,266 @@
+{
+  "config": {
+    "step": {
+      "provider": {
+        "title": "选择 AI 提供商",
+        "description": "选择要用于此实例的 AI 服务提供商。",
+        "data": {
+          "api_provider": "API 提供商",
+          "context_messages": "要保留的上下文消息数量 (1-20)"
+        }
+      },
+      "user": {
+        "title": "配置 HA Text AI 实例",
+        "description": "使用您选择的提供商设置新的 AI 助手实例。",
+        "data": {
+          "name": "实例名称（例如，“GPT 助手”、“Claude 助手”）",
+          "api_key": "用于身份验证的 API 密钥",
+          "model": "要使用的 AI 模型",
+          "temperature": "回复创意度 (0-2，数值越低，回复越聚焦)",
+          "max_tokens": "最大回复长度（1-4096 个 Token）",
+          "api_endpoint": "自定义 API 端点 URL（可选）",
+          "api_provider": "API 提供商",
+          "request_interval": "请求之间的最短时间间隔（0.1-60 秒）",
+          "context_messages": "要保留的上下文消息数量 (1-20)",
+          "max_history_size": "最大对话历史记录大小 (1-100)"
+        }
+      }
+    },
+    "error": {
+      "name_exists": "已存在具有此名称的实例",
+      "invalid_name": "无效的实例名称",
+      "invalid_auth": "身份验证失败 - 请检查您的 API 密钥",
+      "invalid_api_key": "无效的 API 密钥 - 请验证您的凭据",
+      "cannot_connect": "无法连接到 API 服务",
+      "invalid_model": "所选模型不可用",
+      "rate_limit": "超出速率限制",
+      "context_length": "上下文长度超出限制",
+      "rate_limit_exceeded": "API 速率限制已超出",
+      "maintenance": "服务正在维护中",
+      "invalid_response": "收到无效的 API 响应",
+      "api_error": "发生 API 服务错误",
+      "timeout": "请求超时",
+      "invalid_instance": "指定的实例无效",
+      "unknown": "发生意外错误",
+      "empty": "名称不能为空",
+      "invalid_characters": "名称只能包含字母、数字、空格、下划线和连字符",
+      "name_too_long": "名称必须为 50 个字符或更少"
+    }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "title": "更新实例设置",
+        "description": "修改此 AI 助手实例的设置。",
+        "data": {
+          "model": "AI 模型",
+          "temperature": "回复创意度 (0-2)",
+          "max_tokens": "最大回复长度 (1-4096)",
+          "request_interval": "最短请求间隔 (0.1-60 秒)",
+          "context_messages": "包含在上下文中的先前消息数 (1-20)",
+          "max_history_size": "最大对话历史记录大小 (1-100)"
+        }
+      }
+    }
+  },
+  "services": {
+    "ask_question": {
+      "name": "提问 (HA Text AI)",
+      "description": "向 AI 模型发送问题并接收详细的回复。回复将存储在对话历史记录中，以后可以检索。",
+      "fields": {
+        "instance": {
+          "name": "实例",
+          "description": "要使用的 HA Text AI 实例的名称"
+        },
+        "question": {
+          "name": "问题",
+          "description": "您要向 AI 助手提出的问题或提示"
+        },
+        "context_messages": {
+          "name": "上下文消息",
+          "description": "包含在上下文中的先前消息数 (1-20)"
+        },
+        "system_prompt": {
+          "name": "系统提示",
+          "description": "可选系统提示，用于为特定问题设置上下文"
+        },
+        "model": {
+          "name": "模型",
+          "description": "选择要使用的 AI 模型（可选，覆盖默认设置）"
+        },
+        "temperature": {
+          "name": "温度",
+          "description": "控制回复创意度 (0.0-2.0)"
+        },
+        "max_tokens": {
+          "name": "最大 Token 数",
+          "description": "回复的最大长度（1-4096 个 Token）"
+        }
+      }
+    },
+    "clear_history": {
+      "name": "清除历史记录",
+      "description": "删除对话历史记录中所有存储的问题和回复",
+      "fields": {
+        "instance": {
+          "name": "实例",
+          "description": "要清除历史记录的 HA Text AI 实例的名称"
+        }
+      }
+    },
+    "get_history": {
+      "name": "获取历史记录",
+      "description": "检索对话历史记录，并可选择进行过滤和排序",
+      "fields": {
+        "instance": {
+          "name": "实例",
+          "description": "要从中获取历史记录的 HA Text AI 实例的名称"
+        },
+        "limit": {
+          "name": "限制",
+          "description": "要返回的对话数量 (1-100)"
+        },
+        "filter_model": {
+          "name": "筛选模型",
+          "description": "按特定 AI 模型筛选对话"
+        },
+        "start_date": {
+          "name": "开始日期",
+          "description": "从该日期/时间开始筛选对话"
+        },
+        "include_metadata": {
+          "name": "包含元数据",
+          "description": "包含其他信息，例如使用的 Token 数、响应时间等。"
+        },
+        "sort_order": {
+          "name": "排序顺序",
+          "description": "结果的排序顺序（最新的或最早的优先）"
+        }
+      }
+    },
+    "set_system_prompt": {
+      "name": "设置系统提示",
+      "description": "为所有将来的对话设置默认系统行为说明",
+      "fields": {
+        "instance": {
+          "name": "实例",
+          "description": "要为其设置系统提示的 HA Text AI 实例的名称"
+        },
+        "prompt": {
+          "name": "系统提示",
+          "description": "定义 AI 如何行为和响应的说明"
+        }
+      }
+    }
+  },
+  "entity": {
+    "sensor": {
+      "ha_text_ai": {
+        "name": "{name}",
+        "state": {
+          "ready": "就绪",
+          "processing": "处理中",
+          "error": "错误",
+          "disconnected": "已断开连接",
+          "rate_limited": "速率限制",
+          "maintenance": "维护",
+          "initializing": "初始化中",
+          "retrying": "重试中",
+          "queued": "排队中"
+        },
+        "state_attributes": {
+          "question": {
+            "name": "最后一个问题"
+          },
+          "response": {
+            "name": "最后一个回复"
+          },
+          "model": {
+            "name": "当前模型"
+          },
+          "temperature": {
+            "name": "温度"
+          },
+          "max_tokens": {
+            "name": "最大 Token 数"
+          },
+          "system_prompt": {
+            "name": "系统提示"
+          },
+          "response_time": {
+            "name": "上次回复时间"
+          },
+          "total_responses": {
+            "name": "总回复次数"
+          },
+          "error_count": {
+            "name": "错误计数"
+          },
+          "last_error": {
+            "name": "上次错误"
+          },
+          "api_status": {
+            "name": "API 状态"
+          },
+          "tokens_used": {
+            "name": "已使用的 Token 总数"
+          },
+          "average_response_time": {
+            "name": "平均回复时间"
+          },
+          "last_request_time": {
+            "name": "上次请求时间"
+          },
+          "is_processing": {
+            "name": "处理状态"
+          },
+          "is_rate_limited": {
+            "name": "速率限制状态"
+          },
+          "is_maintenance": {
+            "name": "维护状态"
+          },
+          "api_version": {
+            "name": "API 版本"
+          },
+          "endpoint_status": {
+            "name": "端点状态"
+          },
+          "performance_metrics": {
+            "name": "性能指标"
+          },
+          "history_size": {
+            "name": "历史记录大小"
+          },
+          "uptime": {
+            "name": "正常运行时间"
+          },
+          "total_tokens": {
+            "name": "总 Token 数"
+          },
+          "prompt_tokens": {
+            "name": "提示 Token 数"
+          },
+          "completion_tokens": {
+            "name": "完成 Token 数"
+          },
+          "successful_requests": {
+            "name": "成功请求数"
+          },
+          "failed_requests": {
+            "name": "失败请求数"
+          },
+          "average_latency": {
+            "name": "平均延迟"
+          },
+          "max_latency": {
+            "name": "最大延迟"
+          },
+          "min_latency": {
+            "name": "最小延迟"
+          }
+        }
+      }
+    }
+  }
+}

hacs.json

@@ -1,9 +1,5 @@
 {
   "name": "HA text AI",
   "render_readme": true,
-  "icon": "mdi:robot",
-  "domains": ["sensor"],
-  "homeassistant": "2024.11.0",
-  "version": "2.0.0",
-  "documentation": "https://github.com/smkrv/ha-text-ai"
+  "homeassistant": "2024.11.0"
 }

structure.md

@@ -2,18 +2,24 @@
 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
-│
-└── strings/
-    ├── en.json
-    ├── de.json
-    └── ru.json
+    ├── 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
 ```