node-red-contrib-knx-ultimate 6.3.15 → 6.3.16

package/nodes/locales/de/knxUltimateAI.html

@@ -37,6 +37,11 @@ Die enthaltene Vorlage **windkh/node-red-contrib-telegrambot** folgt dem Receive
 
 Die enthaltene Vorlage **RedBot / node-red-contrib-chatbot (Telegram)** folgt dem gemeinsamen RedBot-Nachrichtenformat. Verbinden Sie `chatbot-telegram-receive` direkt mit KNX AI und Ausgang 3 direkt mit `chatbot-telegram-send`; ein separater Callback-Node ist nicht erforderlich, da RedBot Postbacks von Inline-Schaltflächen in normale Eingangsnachrichten umwandelt. Die Eingangszuordnung liest `transport`, `chatId`, `type`, `content` und die Telegram-Sprache. Die Ausgangszuordnung bewahrt die RedBot-Trackingdaten `originalMessage`, `chat`, `api` und `client` und erzeugt anschließend entweder einen `message`-Payload oder einen `inline-buttons`-Payload mit `postback`-Aktionen zur Bestätigung. RedBot bleibt eine separate optionale Abhängigkeit.
 
+### Automatisch erkannte Kamera-Adapter
+Installierte Kamerapakete können KNX AI zur Laufzeit einen Kamera-Adapter bereitstellen. Es gibt weder eine Auswahl noch einen Kamera-Node, der mit KNX AI verbunden werden muss: verfügbare Adapter, Controller und Kameras werden automatisch erkannt und in den Chat-Kontext aufgenommen. `node-red-contrib-unifi-ultimate` ist der erste unterstützte Anbieter; weitere Pakete wie `hikvision-ultimate` können sich über denselben herstellerneutralen Vertrag registrieren.
+
+Der Benutzer kann einen aktuellen Snapshot anfordern oder das Vision-Modell nach dem sichtbaren Inhalt fragen. Die Telegram- und RedBot-Vorlagen senden das Bild als natives Foto mit Bildunterschrift. Außerdem lassen sich dauerhafte Benachrichtigungen für Bewegung, das Überqueren einer intelligenten Linie oder das Betreten einer Einbruchs-/Verweilzone erstellen, optional auf erkannte Personen und eine genau benannte Linie oder Zone begrenzt. Diese Regeln werden in derselben Datei `knxai-chat-context.md` gespeichert und nach einem Neustart von Node-RED wiederhergestellt. UniFi-Ereignisse und Snapshot-Anfragen laufen direkt über den erkannten Anbieter; Ausgang 4 von KNX AI und zusätzliche Flow-Verkabelung sind nicht erforderlich.
+
 ## Proaktive Hausintelligenz und begrenztes Gedächtnis
 Der Unterbereich **Proaktives Zuhause & Gedächtnis** in **Gespräche & Zuhause** aktiviert proaktive Benachrichtigungen auf Wunsch des Benutzers. Aus ETS-Hierarchie, Namen, Rollen und DPTs erstellt der Node ein deterministisches semantisches Modell für Rollläden, Fenster, Türen, Licht, Temperatur, Klima, Anwesenheit und Alarme mit italienischen, englischen, deutschen, französischen, spanischen und chinesischen Begriffen. Der erste proaktive Detektor überwacht nur zuverlässig erkannte Nicht-Befehlszustände von Rollläden/Fenstern/Türen. Nach der konfigurierten Offenzeit und außerhalb der Ruhezeiten gibt Ausgang 3 eine lokalisierte Nachricht mit `msg.knxAi.type = "proactive_notification"` aus. Ausgang 4 wird niemals proaktiv verwendet und KNX wird nicht selbstständig verändert; eine spätere Benutzeranfrage durchläuft weiterhin die normale Validierung und Bestätigung.
 

package/nodes/locales/de/knxUltimateAI.json

@@ -4,6 +4,7 @@
     "sections": {
       "groupAssistant": "KI-Assistent",
       "groupChatHome": "Gespräche & Zuhause",
+      "detectedAdapters": "Automatisch erkannte Adapter",
       "groupKnxAnalysis": "KNX-Verkehrsanalyse",
       "quickSetup": "Assistent einrichten",
       "capture": "Bus-Telegrammeingang",
@@ -93,6 +94,12 @@
       "installOllamaModelFailed": "Failed to install Ollama model",
       "ollamaInstallSteps": "1) Open the model library and copy the model name (for example llama3.1). 2) Put the name in the Model field and click Install it.",
       "ollamaStartedAuto": "Ollama server started automatically.",
+      "detectedAdaptersLoading": "Installierte Adapter werden erkannt…",
+      "detectedAdaptersNone": "Kein automatischer Adapter erkannt.",
+      "detectedAdaptersUnavailable": "Die automatische Adaptererkennung ist vorübergehend nicht verfügbar.",
+      "detectedAdapterDetected": "Erkannt",
+      "detectedAdapterControllers": "Controller",
+      "detectedAdapterCameras": "Kameras",
       "chatAdapterIntro": "Wählen Sie eine Vorlage, um den Code für Ein- und Ausgang einzufügen. Die Liste wird aus der mitgelieferten Chat-Adapter-Datei geladen; der erzeugte Code bleibt bearbeitbar.",
       "chatAdapterCodeHelp": "Zuordnungen laufen synchron. Geben Sie msg zurück, um fortzufahren, oder keinen Wert, um die Nachricht zu verwerfen. Fehler werden abgefangen und gemeldet, ohne Node-RED anzuhalten.",
       "homeIntelligenceIntro": "Der Node erstellt ein mehrsprachiges semantisches ETS-Modell und kann den Chat benachrichtigen, wenn ein zuverlässig erkannter Rollladen, ein Fenster oder eine Tür offen bleibt. Er sendet niemals selbstständig einen KNX-Befehl.",

package/nodes/locales/en/knxUltimateAI.html

@@ -37,6 +37,11 @@ The included **windkh/node-red-contrib-telegrambot** preset follows the package'
 
 The included **RedBot / node-red-contrib-chatbot (Telegram)** preset follows RedBot's common message contract. Connect `chatbot-telegram-receive` directly to KNX AI and output 3 directly to `chatbot-telegram-send`; no separate callback node is needed because RedBot converts inline-button postbacks into normal inbound messages. The input mapping reads `transport`, `chatId`, `type`, `content`, and the Telegram language. The output mapping preserves RedBot's `originalMessage`, `chat`, `api`, and `client` tracking data, then emits either a `message` payload or an `inline-buttons` payload containing `postback` actions for confirmation. RedBot remains a separate optional dependency.
 
+### Automatically detected camera adapters
+Installed camera packages can publish a camera adapter to KNX AI at runtime. There is no selector and no camera node to wire to KNX AI: available adapters, controllers and cameras are detected automatically and included in the chat context. `node-red-contrib-unifi-ultimate` is the first supported provider; other packages, such as `hikvision-ultimate`, can register through the same vendor-neutral contract.
+
+The user can ask for a current snapshot or ask the vision model what is visible. Telegram and RedBot presets emit the returned image as a native photo with a caption. The user can also create persistent notifications for motion, a smart line crossing or entry into an intrusion/loiter zone, optionally limited to detected people and to an exact named line or zone. These rules are stored in the same `knxai-chat-context.md` file and are restored after Node-RED restarts. UniFi event subscriptions and snapshot requests are made directly through the detected provider; KNX AI output 4 is not involved and no intermediate flow wiring is required.
+
 ## Proactive home intelligence and bounded memory
 The **Proactive home & memory** subsection inside **Conversations & home** enables opt-in proactive notifications. From ETS hierarchy, names, roles and DPTs, the node builds a deterministic semantic model for covers, windows, doors, lights, temperature, climate, occupancy and alarms using Italian, English, German, French, Spanish and Chinese terms. The first proactive detector watches only reliably recognized non-command cover/window/door states. After the configured open duration and outside quiet hours, output 3 emits a localized message with `msg.knxAi.type = "proactive_notification"`. It never emits output 4 or changes KNX autonomously; a subsequent user request still uses the normal validation and confirmation workflow.
 

package/nodes/locales/en/knxUltimateAI.json

@@ -4,6 +4,7 @@
     "sections": {
       "groupAssistant": "AI assistant",
       "groupChatHome": "Conversations & home",
+      "detectedAdapters": "Automatically detected adapters",
       "groupKnxAnalysis": "KNX traffic analysis",
       "quickSetup": "Assistant setup",
       "capture": "Bus telegram input",
@@ -93,6 +94,12 @@
       "installOllamaModelFailed": "Failed to install Ollama model",
       "ollamaInstallSteps": "1) Open the model library and copy the model name (for example llama3.1). 2) Put the name in the Model field and click Install it.",
       "ollamaStartedAuto": "Ollama server started automatically.",
+      "detectedAdaptersLoading": "Detecting installed adapters…",
+      "detectedAdaptersNone": "No automatic adapter detected.",
+      "detectedAdaptersUnavailable": "Automatic adapter detection is temporarily unavailable.",
+      "detectedAdapterDetected": "Detected",
+      "detectedAdapterControllers": "Controllers",
+      "detectedAdapterCameras": "Cameras",
       "chatAdapterIntro": "Choose a mapping preset to insert its input and output code. The list is loaded from the packaged chat-adapter mappings file; the generated code remains editable.",
       "chatAdapterCodeHelp": "Mappings run synchronously. Return msg to continue or return no value to discard it. Errors are caught and reported without stopping Node-RED.",
       "homeIntelligenceIntro": "The node builds a multilingual semantic ETS model and can notify the chat when a reliably recognized cover, window, or door remains open. It never sends a KNX command proactively.",

package/nodes/locales/es/knxUltimateAI.html

@@ -37,6 +37,11 @@ El preajuste incluido **windkh/node-red-contrib-telegrambot** sigue el contrato
 
 El preajuste incluido **RedBot / node-red-contrib-chatbot (Telegram)** sigue el formato común de mensajes de RedBot. Conecta directamente `chatbot-telegram-receive` a KNX AI y la salida 3 a `chatbot-telegram-send`; no hace falta un nodo callback separado porque RedBot convierte los postbacks de los botones inline en mensajes de entrada normales. El mapeo de entrada lee `transport`, `chatId`, `type`, `content` y el idioma de Telegram. El mapeo de salida conserva los datos de seguimiento RedBot `originalMessage`, `chat`, `api` y `client`, y después emite un payload `message` o un payload `inline-buttons` con acciones `postback` de confirmación. RedBot sigue siendo una dependencia opcional separada.
 
+### Adaptadores de cámara detectados automáticamente
+Los paquetes de cámaras instalados pueden publicar en tiempo de ejecución un adaptador para KNX AI. No hay selector ni nodo de cámara que conectar a KNX AI: los adaptadores, controladores y cámaras disponibles se detectan automáticamente y se incorporan al contexto del chat. `node-red-contrib-unifi-ultimate` es el primer proveedor compatible; otros paquetes, como `hikvision-ultimate`, pueden registrarse mediante el mismo contrato independiente del fabricante.
+
+El usuario puede pedir una captura actual o preguntar al modelo de visión qué se ve. Los preajustes de Telegram y RedBot envían la imagen como foto nativa con pie. También se pueden crear notificaciones persistentes por movimiento, cruce de una línea inteligente o entrada en una zona de intrusión/merodeo, limitadas opcionalmente a personas detectadas y a una línea o zona concreta por nombre. Estas reglas se guardan en el mismo archivo `knxai-chat-context.md` y se restauran después de reiniciar Node-RED. Las suscripciones a eventos UniFi y las solicitudes de captura se realizan directamente a través del proveedor detectado; no interviene la salida 4 de KNX AI ni hace falta cableado intermedio en el flujo.
+
 ## Inteligencia doméstica proactiva y memoria limitada
 La subsección **Hogar proactivo y memoria** dentro de **Conversaciones y hogar** activa las notificaciones proactivas de forma opcional. A partir de la jerarquía ETS, nombres, roles y DPT, el nodo crea un modelo semántico determinista para persianas, ventanas, puertas, luces, temperatura, clima, presencia y alarmas usando términos italianos, ingleses, alemanes, franceses, españoles y chinos. El primer detector proactivo vigila únicamente estados que no sean de comando de persianas/ventanas/puertas reconocidos con suficiente fiabilidad. Tras el tiempo abierto configurado y fuera de las horas silenciosas, la salida 3 emite un mensaje localizado con `msg.knxAi.type = "proactive_notification"`. Nunca emite por la salida 4 ni modifica KNX de manera autónoma; una solicitud posterior del usuario sigue pasando por la validación y confirmación normales.
 

package/nodes/locales/es/knxUltimateAI.json

@@ -4,6 +4,7 @@
     "sections": {
       "groupAssistant": "Asistente IA",
       "groupChatHome": "Conversaciones y hogar",
+      "detectedAdapters": "Adaptadores detectados automáticamente",
       "groupKnxAnalysis": "Análisis del tráfico KNX",
       "quickSetup": "Configurar el asistente",
       "capture": "Telegramas del bus",
@@ -85,6 +86,12 @@
       "installOllamaModelFailed": "Failed to install Ollama model",
       "ollamaInstallSteps": "1) Open the model library and copy the model name (for example llama3.1). 2) Put the name in the Model field and click Install it.",
       "ollamaStartedAuto": "Ollama server started automatically.",
+      "detectedAdaptersLoading": "Detectando adaptadores instalados…",
+      "detectedAdaptersNone": "No se detectó ningún adaptador automático.",
+      "detectedAdaptersUnavailable": "La detección automática de adaptadores no está disponible temporalmente.",
+      "detectedAdapterDetected": "Detectado",
+      "detectedAdapterControllers": "Controladores",
+      "detectedAdapterCameras": "Cámaras",
       "chatAdapterIntro": "Elige un preajuste para insertar su código de mapeo de entrada y salida. La lista se carga desde el archivo de adaptadores de chat incluido; el código generado sigue siendo editable.",
       "chatAdapterCodeHelp": "Los mapeos se ejecutan de forma síncrona. Devuelve msg para continuar o ningún valor para descartarlo. Los errores se capturan y notifican sin detener Node-RED.",
       "homeIntelligenceIntro": "El nodo crea un modelo ETS semántico multilingüe y puede avisar al chat cuando una persiana, ventana o puerta reconocida con suficiente fiabilidad permanece abierta. Nunca envía por sí solo un comando KNX.",

package/nodes/locales/fr/knxUltimateAI.html

@@ -37,6 +37,11 @@ Le préréglage inclus **windkh/node-red-contrib-telegrambot** suit le contrat r
 
 Le préréglage inclus **RedBot / node-red-contrib-chatbot (Telegram)** suit le format de message commun de RedBot. Connectez directement `chatbot-telegram-receive` à KNX AI et la sortie 3 à `chatbot-telegram-send` ; aucun nœud de callback séparé n’est nécessaire, car RedBot convertit les postbacks des boutons inline en messages entrants ordinaires. Le mappage d’entrée lit `transport`, `chatId`, `type`, `content` et la langue Telegram. Le mappage de sortie conserve les données de suivi RedBot `originalMessage`, `chat`, `api` et `client`, puis émet soit un payload `message`, soit un payload `inline-buttons` avec des actions `postback` de confirmation. RedBot reste une dépendance optionnelle distincte.
 
+### Adaptateurs de caméra détectés automatiquement
+Les paquets de caméra installés peuvent publier à l’exécution un adaptateur pour KNX AI. Il n’existe aucun sélecteur ni nœud caméra à relier à KNX AI : les adaptateurs, contrôleurs et caméras disponibles sont détectés automatiquement et ajoutés au contexte du chat. `node-red-contrib-unifi-ultimate` est le premier fournisseur pris en charge ; d’autres paquets, tels que `hikvision-ultimate`, peuvent s’enregistrer avec le même contrat indépendant du fabricant.
+
+L’utilisateur peut demander une capture actuelle ou demander au modèle de vision ce qui est visible. Les préréglages Telegram et RedBot envoient l’image comme photo native avec une légende. L’utilisateur peut aussi créer des notifications persistantes pour un mouvement, le franchissement d’une ligne intelligente ou l’entrée dans une zone d’intrusion/de stationnement, avec une limitation facultative aux personnes détectées et à une ligne ou zone nommée précise. Ces règles sont stockées dans le même fichier `knxai-chat-context.md` et restaurées après les redémarrages de Node-RED. Les abonnements aux événements UniFi et les demandes de capture passent directement par le fournisseur détecté ; la sortie 4 de KNX AI et un câblage intermédiaire ne sont pas nécessaires.
+
 ## Intelligence domestique proactive et mémoire limitée
 La sous-section **Maison proactive et mémoire** de **Conversations et maison** active les notifications proactives sur choix de l’utilisateur. À partir de la hiérarchie ETS, des noms, rôles et DPT, le nœud crée un modèle sémantique déterministe pour les volets, fenêtres, portes, éclairages, températures, climat, présence et alarmes avec des termes italiens, anglais, allemands, français, espagnols et chinois. Le premier détecteur proactif surveille uniquement les états hors commande de volets/fenêtres/portes reconnus avec une fiabilité suffisante. Après la durée d’ouverture configurée et hors heures silencieuses, la sortie 3 émet un message localisé avec `msg.knxAi.type = "proactive_notification"`. Il n’émet jamais sur la sortie 4 et ne modifie jamais KNX de façon autonome ; une demande ultérieure de l’utilisateur passe toujours par la validation et la confirmation normales.
 

package/nodes/locales/fr/knxUltimateAI.json

@@ -4,6 +4,7 @@
     "sections": {
       "groupAssistant": "Assistant IA",
       "groupChatHome": "Conversations et maison",
+      "detectedAdapters": "Adaptateurs détectés automatiquement",
       "groupKnxAnalysis": "Analyse du trafic KNX",
       "quickSetup": "Configurer l'assistant",
       "capture": "Télégrammes du bus",
@@ -85,6 +86,12 @@
       "installOllamaModelFailed": "Failed to install Ollama model",
       "ollamaInstallSteps": "1) Open the model library and copy the model name (for example llama3.1). 2) Put the name in the Model field and click Install it.",
       "ollamaStartedAuto": "Ollama server started automatically.",
+      "detectedAdaptersLoading": "Détection des adaptateurs installés…",
+      "detectedAdaptersNone": "Aucun adaptateur automatique détecté.",
+      "detectedAdaptersUnavailable": "La détection automatique des adaptateurs est temporairement indisponible.",
+      "detectedAdapterDetected": "Détecté",
+      "detectedAdapterControllers": "Contrôleurs",
+      "detectedAdapterCameras": "Caméras",
       "chatAdapterIntro": "Choisissez un préréglage pour insérer son code de mappage d’entrée et de sortie. La liste est chargée depuis le fichier d’adaptateurs de chat fourni ; le code généré reste modifiable.",
       "chatAdapterCodeHelp": "Les mappages s’exécutent de façon synchrone. Renvoyez msg pour continuer ou aucune valeur pour l’écarter. Les erreurs sont interceptées et signalées sans arrêter Node-RED.",
       "homeIntelligenceIntro": "Le nœud crée un modèle ETS sémantique multilingue et peut avertir le chat lorsqu'un volet, une fenêtre ou une porte reconnu avec suffisamment de fiabilité reste ouvert. Il n'envoie jamais de commande KNX de manière autonome.",

package/nodes/locales/it/knxUltimateAI.html

@@ -37,6 +37,11 @@ Il preset incluso **windkh/node-red-contrib-telegrambot** segue il contratto rec
 
 Il preset incluso **RedBot / node-red-contrib-chatbot (Telegram)** segue il formato comune dei messaggi RedBot. Collega direttamente `chatbot-telegram-receive` a KNX AI e l'uscita 3 direttamente a `chatbot-telegram-send`; non serve un nodo callback separato perché RedBot converte i postback dei pulsanti inline in normali messaggi in ingresso. La mappatura d'ingresso legge `transport`, `chatId`, `type`, `content` e la lingua Telegram. Quella d'uscita conserva i dati di tracciamento RedBot `originalMessage`, `chat`, `api` e `client`, quindi emette un payload `message` oppure un payload `inline-buttons` con azioni `postback` per la conferma. RedBot resta una dipendenza opzionale separata.
 
+### Adapter telecamera rilevati automaticamente
+I pacchetti di telecamere installati possono pubblicare a runtime un adapter per KNX AI. Non esistono selettori né nodi telecamera da collegare a KNX AI: adapter, controller e telecamere disponibili vengono rilevati automaticamente e inseriti nel contesto della chat. `node-red-contrib-unifi-ultimate` è il primo provider supportato; altri pacchetti, come `hikvision-ultimate`, possono registrarsi tramite lo stesso contratto indipendente dal produttore.
+
+L'utente può chiedere uno snapshot aggiornato oppure domandare al modello vision che cosa è visibile. I preset Telegram e RedBot inviano l'immagine come foto nativa con didascalia. L'utente può anche creare notifiche persistenti per movimento, attraversamento di una linea intelligente o ingresso in una zona di intrusione/stazionamento, limitandole facoltativamente alle persone rilevate e a una linea o zona nominata esatta. Le regole vengono salvate nello stesso file `knxai-chat-context.md` e ripristinate dopo i riavvii di Node-RED. Le sottoscrizioni agli eventi UniFi e le richieste snapshot avvengono direttamente tramite il provider rilevato: l'uscita 4 di KNX AI non è coinvolta e non servono collegamenti intermedi nel flow.
+
 ## Intelligenza domestica proattiva e memoria limitata
 La sottosezione **Casa proattiva e memoria** dentro **Conversazioni e casa** abilita le notifiche proattive su scelta dell'utente. Da gerarchia ETS, nomi, ruoli e DPT, il nodo crea un modello semantico deterministico per persiane, finestre, porte, luci, temperatura, clima, presenza e allarmi usando termini italiani, inglesi, tedeschi, francesi, spagnoli e cinesi. Il primo rilevatore proattivo osserva soltanto stati non di comando di persiane/finestre/porte riconosciuti con sufficiente affidabilità. Dopo il tempo di apertura configurato e fuori dalle ore silenziose, l'uscita 3 emette un messaggio localizzato con `msg.knxAi.type = "proactive_notification"`. Non emette mai l'uscita 4 e non modifica autonomamente KNX; un'eventuale richiesta successiva dell'utente passa sempre dalla normale validazione e conferma.
 

package/nodes/locales/it/knxUltimateAI.json

@@ -4,6 +4,7 @@
     "sections": {
       "groupAssistant": "Assistente AI",
       "groupChatHome": "Conversazioni e casa",
+      "detectedAdapters": "Adapter rilevati automaticamente",
       "groupKnxAnalysis": "Analisi traffico KNX",
       "quickSetup": "Configurazione assistente",
       "capture": "Telegrammi dal bus",
@@ -93,6 +94,12 @@
       "installOllamaModelFailed": "Installazione modello Ollama non riuscita",
       "ollamaInstallSteps": "1) Apri la libreria, scegli un modello e copiane il nome (es. llama3.1). 2) Inserisci il nome nel campo Modello e clicca Installalo.",
       "ollamaStartedAuto": "Server Ollama avviato automaticamente.",
+      "detectedAdaptersLoading": "Rilevamento degli adapter installati…",
+      "detectedAdaptersNone": "Nessun adapter automatico rilevato.",
+      "detectedAdaptersUnavailable": "Il rilevamento automatico degli adapter non è momentaneamente disponibile.",
+      "detectedAdapterDetected": "Rilevato",
+      "detectedAdapterControllers": "Controller",
+      "detectedAdapterCameras": "Telecamere",
       "chatAdapterIntro": "Scegli un preset per inserire il codice di mappatura in ingresso e in uscita. La lista viene caricata dal file degli adattatori chat incluso nel pacchetto; il codice generato resta modificabile.",
       "chatAdapterCodeHelp": "Le mappature sono sincrone. Restituisci msg per continuare oppure nessun valore per scartarlo. Gli errori vengono intercettati e segnalati senza arrestare Node-RED.",
       "homeIntelligenceIntro": "Il nodo crea un modello ETS semantico multilingue e può avvisare la chat quando una persiana, finestra o porta riconosciuta con sufficiente affidabilità rimane aperta. Non invia mai autonomamente comandi KNX.",

package/nodes/locales/zh-CN/knxUltimateAI.html

@@ -37,6 +37,11 @@
 
 随附的 **RedBot / node-red-contrib-chatbot (Telegram)** 预设遵循 RedBot 的通用消息格式。将 `chatbot-telegram-receive` 直接连接到 KNX AI，并将输出 3 直接连接到 `chatbot-telegram-send`；无需单独的 callback 节点，因为 RedBot 会把内联按钮的 postback 转换成普通入站消息。输入映射读取 `transport`、`chatId`、`type`、`content` 和 Telegram 语言。输出映射保留 RedBot 的 `originalMessage`、`chat`、`api` 和 `client` 跟踪数据，然后发送 `message` payload，或发送带有确认 `postback` 操作的 `inline-buttons` payload。RedBot 仍是独立的可选依赖项。
 
+### 自动检测的摄像机适配器
+已安装的摄像机软件包可以在运行时向 KNX AI 发布适配器。无需选择器，也无需将摄像机节点连接到 KNX AI：可用的适配器、控制器和摄像机会被自动检测并加入聊天上下文。`node-red-contrib-unifi-ultimate` 是首个受支持的提供方；`hikvision-ultimate` 等其他软件包可通过同一套厂商无关协议注册。
+
+用户可以请求当前快照，或询问视觉模型画面中可见的内容。Telegram 和 RedBot 预设会把图像作为带说明文字的原生照片发送。用户还可以为移动、智能越线或进入入侵/徘徊区域创建持久通知，并可按检测到的人员以及指定名称的线或区域进行限制。这些规则保存在同一个 `knxai-chat-context.md` 文件中，并在 Node-RED 重启后恢复。UniFi 事件订阅和快照请求直接通过检测到的提供方完成；不会使用 KNX AI 输出 4，也不需要中间 Flow 连线。
+
 ## 主动家庭智能与有限记忆
 **对话与家庭**中的**主动家庭与记忆**子部分以可选方式启用主动通知。节点会根据 ETS 层级、名称、角色和 DPT，使用意大利语、英语、德语、法语、西班牙语和中文术语，为卷帘、窗户、门、照明、温度、气候、占用和报警建立确定性的语义模型。首个主动检测器只监视可靠识别且非命令的卷帘/窗户/门状态。超过配置的打开时间且当前不在静默时段时，输出 3 会发送本地化消息，并设置 `msg.knxAi.type = "proactive_notification"`。节点绝不会主动使用输出 4，也不会自行修改 KNX；用户之后提出的任何操作仍须经过正常的校验与确认。
 

package/nodes/locales/zh-CN/knxUltimateAI.json

@@ -4,6 +4,7 @@
     "sections": {
       "groupAssistant": "AI 助手",
       "groupChatHome": "对话与家庭",
+      "detectedAdapters": "自动检测到的适配器",
       "groupKnxAnalysis": "KNX 总线流量分析",
       "quickSetup": "助手配置",
       "capture": "总线报文输入",
@@ -85,6 +86,12 @@
       "installOllamaModelFailed": "Failed to install Ollama model",
       "ollamaInstallSteps": "1) Open the model library and copy the model name (for example llama3.1). 2) Put the name in the Model field and click Install it.",
       "ollamaStartedAuto": "Ollama server started automatically.",
+      "detectedAdaptersLoading": "正在检测已安装的适配器…",
+      "detectedAdaptersNone": "未检测到自动适配器。",
+      "detectedAdaptersUnavailable": "自动适配器检测暂时不可用。",
+      "detectedAdapterDetected": "已检测",
+      "detectedAdapterControllers": "控制器",
+      "detectedAdapterCameras": "摄像机",
       "chatAdapterIntro": "选择预设即可插入输入和输出映射代码。列表从随包提供的聊天适配器文件加载；生成的代码仍可编辑。",
       "chatAdapterCodeHelp": "映射同步运行。返回 msg 以继续，或不返回值以丢弃消息。错误会被捕获并报告，不会停止 Node-RED。",
       "homeIntelligenceIntro": "节点会创建多语言 ETS 语义模型，并在可靠识别的卷帘、窗户或门长时间保持打开时主动通知聊天。它绝不会自行发送 KNX 命令。",

package/nodes/utils/knxAiCamera.js

@@ -0,0 +1,302 @@
+const KNX_AI_CAMERA_REGISTRY_KEY = Symbol.for('node-red.knx-ai.camera-adapters.v1')
+const KNX_AI_CAMERA_IMAGE_MAX_BYTES = 6 * 1024 * 1024
+const KNX_AI_CAMERA_MAX_ACTIONS = 8
+
+const clampText = (value, maxChars = 240) => String(value === undefined || value === null ? '' : value)
+  .trim()
+  .slice(0, Math.max(0, Number(maxChars) || 0))
+
+const normalizeSearchText = value => clampText(value, 300)
+  .normalize('NFKD')
+  .replace(/[\u0300-\u036f]/g, '')
+  .toLocaleLowerCase()
+  .replace(/[^a-z0-9]+/g, ' ')
+  .trim()
+
+const uniqueTexts = values => Array.from(new Set((Array.isArray(values) ? values : [])
+  .map(value => clampText(value, 240))
+  .filter(Boolean)))
+
+// Runtime contract for optional camera suites. A package registers one adapter
+// manifest and one provider per configured controller. Providers expose:
+//   listCameras({ force }) -> camera[]
+//   takeSnapshot({ cameraId, cameraName, highQuality }) -> { data, mediaType, camera }
+//   subscribe(listener) -> unsubscribe(), with normalized camera event objects.
+// The global Symbol lets separately installed Node-RED packages share the same
+// in-process registry without either package importing the other one.
+const getKnxAiCameraAdapterRegistry = () => {
+  const existing = globalThis[KNX_AI_CAMERA_REGISTRY_KEY]
+  if (existing && existing.version === 1 && existing.adapters instanceof Map && existing.providers instanceof Map) return existing
+  const registry = {
+    version: 1,
+    adapters: new Map(),
+    providers: new Map(),
+    listeners: new Set(),
+    registerAdapter (adapter) {
+      if (!adapter || !adapter.id) return
+      this.adapters.set(String(adapter.id), Object.freeze(Object.assign({}, adapter)))
+      this.listeners.forEach(listener => {
+        try { listener({ type: 'adapter_registered', adapter: this.adapters.get(String(adapter.id)) }) } catch (error) { /* ignore */ }
+      })
+    },
+    registerProvider (provider) {
+      if (!provider || !provider.id) return
+      this.providers.set(String(provider.id), provider)
+      this.listeners.forEach(listener => {
+        try { listener({ type: 'provider_registered', provider }) } catch (error) { /* ignore */ }
+      })
+    },
+    unregisterProvider (providerId) {
+      const id = String(providerId || '')
+      const provider = this.providers.get(id)
+      if (!provider) return
+      this.providers.delete(id)
+      this.listeners.forEach(listener => {
+        try { listener({ type: 'provider_unregistered', provider }) } catch (error) { /* ignore */ }
+      })
+    },
+    subscribe (listener) {
+      if (typeof listener !== 'function') return () => {}
+      this.listeners.add(listener)
+      return () => this.listeners.delete(listener)
+    }
+  }
+  globalThis[KNX_AI_CAMERA_REGISTRY_KEY] = registry
+  return registry
+}
+
+const normalizeKnxAiCameraRegistration = (value = {}) => {
+  const source = value && typeof value === 'object' && !Array.isArray(value) ? value : {}
+  const id = clampText(source.cameraId || source.id, 160)
+  const name = clampText(source.cameraName || source.name || id, 240)
+  const state = clampText(source.state, 80).toUpperCase()
+  const online = typeof source.online === 'boolean'
+    ? source.online
+    : state
+      ? ['CONNECTED', 'ONLINE'].includes(state)
+      : null
+  if (!id && !name) return null
+  return {
+    id,
+    name,
+    aliases: uniqueTexts([name, id].concat(Array.isArray(source.aliases) ? source.aliases : [])),
+    source: clampText(source.source || 'camera-adapter', 80),
+    adapterId: clampText(source.adapterId, 120),
+    adapterTitle: clampText(source.adapterTitle, 240),
+    providerId: clampText(source.providerId, 200),
+    controllerId: clampText(source.controllerId, 160),
+    controllerName: clampText(source.controllerName, 240),
+    nativeCameraId: clampText(source.nativeCameraId, 160),
+    state,
+    online,
+    objectTypes: uniqueTexts(source.objectTypes).map(normalizeCameraObjectType).filter(Boolean).slice(0, 24),
+    lines: (Array.isArray(source.lines) ? source.lines : []).slice(0, 80),
+    zones: (Array.isArray(source.zones) ? source.zones : []).slice(0, 80),
+    lastSeenAt: clampText(source.lastSeenAt || new Date().toISOString(), 64)
+  }
+}
+
+const resolveKnxAiCamera = ({ target, cameras } = {}) => {
+  const requested = normalizeSearchText(target)
+  const list = (Array.isArray(cameras) ? cameras : [])
+    .map(normalizeKnxAiCameraRegistration)
+    .filter(Boolean)
+  if (!requested) return { camera: null, ambiguous: false }
+
+  const exact = list.filter(camera => [camera.id, camera.name].concat(camera.aliases)
+    .some(alias => normalizeSearchText(alias) === requested))
+  if (exact.length === 1) return { camera: exact[0], ambiguous: false }
+  if (exact.length > 1) return { camera: null, ambiguous: true }
+
+  const partial = list.filter(camera => [camera.id, camera.name].concat(camera.aliases)
+    .some(alias => {
+      const normalizedAlias = normalizeSearchText(alias)
+      return normalizedAlias && (normalizedAlias.includes(requested) || requested.includes(normalizedAlias))
+    }))
+  if (partial.length === 1) return { camera: partial[0], ambiguous: false }
+  return { camera: null, ambiguous: partial.length > 1 }
+}
+
+const normalizeCameraEventType = value => {
+  const raw = normalizeSearchText(value).replace(/\s+/g, '')
+  if (['smartdetect', 'objectdetect', 'objectdetection', 'smartdetection'].includes(raw)) return 'smartDetect'
+  if (['smartdetectline', 'line', 'linecrossing', 'crossline'].includes(raw)) return 'smartDetectLine'
+  if (['smartdetectzone', 'zone', 'intrusionzone', 'intrusion'].includes(raw)) return 'smartDetectZone'
+  if (['smartdetectloiterzone', 'loiter', 'loiterzone'].includes(raw)) return 'smartDetectLoiterZone'
+  if (['motion', 'movement'].includes(raw)) return 'motion'
+  if (['ring', 'doorbell'].includes(raw)) return 'ring'
+  if (['smartaudiodetect', 'audio'].includes(raw)) return 'smartAudioDetect'
+  return clampText(value, 80)
+}
+
+const normalizeCameraObjectType = value => {
+  const raw = normalizeSearchText(value).replace(/\s+/g, '')
+  if (['person', 'people', 'persona', 'persone', 'human', 'someone', 'qualcuno'].includes(raw)) return 'person'
+  if (['animal', 'animale', 'animali', 'pet', 'pets', 'dog', 'cat', 'cane', 'gatto'].includes(raw)) return 'animal'
+  if (['vehicle', 'vehicles', 'veicolo', 'veicoli', 'car', 'auto', 'automobile'].includes(raw)) return 'vehicle'
+  if (['face', 'volto', 'faccia'].includes(raw)) return 'face'
+  if (['licenseplate', 'numberplate', 'targa'].includes(raw)) return 'licenseplate'
+  if (['package', 'parcel', 'pacco'].includes(raw)) return 'package'
+  return normalizeSearchText(value).replace(/\s+/g, '')
+}
+
+const normalizeCameraActionType = value => {
+  const raw = normalizeSearchText(value).replace(/\s+/g, '_')
+  if (['snapshot', 'get_snapshot', 'send_snapshot', 'camera_snapshot'].includes(raw)) return 'snapshot'
+  if (['analyze', 'analyse', 'analyze_snapshot', 'describe_snapshot', 'vision'].includes(raw)) return 'analyze'
+  if (['watch', 'subscribe', 'notify', 'create_watch'].includes(raw)) return 'watch'
+  if (['unwatch', 'unsubscribe', 'stop', 'remove_watch', 'delete_watch'].includes(raw)) return 'unwatch'
+  if (['list', 'list_watches', 'show_watches'].includes(raw)) return 'list_watches'
+  return ''
+}
+
+const normalizeKnxAiCameraAction = (value, cameras = []) => {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return null
+  const type = normalizeCameraActionType(value.type || value.action || value.operation)
+  if (!type) return null
+  const target = clampText(value.cameraId || value.cameraName || value.camera || value.target, 240)
+  const resolved = resolveKnxAiCamera({ target, cameras })
+  const camera = resolved.camera
+  let eventType = normalizeCameraEventType(value.eventType || value.event)
+  const requestedScope = clampText(value.scopeId || value.scopeName || value.zoneId || value.lineId || value.zone || value.line, 240)
+  const availableScopes = camera
+    ? eventType === 'smartDetectLine'
+      ? camera.lines
+      : ['smartDetectZone', 'smartDetectLoiterZone'].includes(eventType)
+        ? camera.zones
+        : []
+    : []
+  const normalizedScopeTarget = normalizeSearchText(requestedScope)
+  const matchingScopes = normalizedScopeTarget
+    ? (Array.isArray(availableScopes) ? availableScopes : []).filter(scope => [scope && scope.id, scope && scope.name]
+        .some(candidate => normalizeSearchText(candidate) === normalizedScopeTarget))
+    : []
+  const resolvedScope = matchingScopes.length === 1 ? matchingScopes[0] : null
+  const objectTypes = uniqueTexts(Array.isArray(value.objectTypes)
+    ? value.objectTypes
+    : [value.objectType || value.smartDetectType]).map(normalizeCameraObjectType).filter(Boolean).slice(0, 12)
+  // A plain motion event has no classified object metadata. Convert requests
+  // such as "motion caused by a person/animal" to the generic smart-detection
+  // family so they can match Protect zone, line, or loiter detections.
+  if (type === 'watch' && eventType === 'motion' && objectTypes.length > 0) eventType = 'smartDetect'
+  return {
+    type,
+    cameraId: camera ? camera.id : clampText(value.cameraId, 160),
+    cameraName: camera ? camera.name : clampText(value.cameraName || value.camera || value.target, 240),
+    unresolvedTarget: camera ? '' : target,
+    unresolved: Boolean(target && !camera),
+    ambiguous: resolved.ambiguous,
+    eventType,
+    scopeId: resolvedScope ? clampText(resolvedScope.id, 160) : clampText(value.scopeId || value.zoneId || value.lineId, 160),
+    scopeName: resolvedScope ? clampText(resolvedScope.name || resolvedScope.id, 240) : clampText(value.scopeName || value.zone || value.line, 240),
+    unresolvedScope: Boolean(requestedScope && camera && !resolvedScope),
+    ambiguousScope: matchingScopes.length > 1,
+    objectTypes,
+    cooldownSeconds: Math.max(10, Math.min(86400, Number(value.cooldownSeconds) || 60)),
+    sendSnapshot: value.sendSnapshot !== false,
+    reason: clampText(value.reason, 500)
+  }
+}
+
+const normalizeKnxAiCameraActions = ({ actions, cameras } = {}) => (Array.isArray(actions) ? actions : [])
+  .slice(0, KNX_AI_CAMERA_MAX_ACTIONS)
+  .map(action => normalizeKnxAiCameraAction(action, cameras))
+  .filter(Boolean)
+
+const normalizeKnxAiCameraEvent = value => {
+  const meta = value && typeof value === 'object' && !Array.isArray(value) && value.eventType
+    ? value
+    : null
+  if (!meta) return null
+  return {
+    cameraId: clampText(meta.cameraId, 160),
+    cameraName: clampText(meta.cameraName, 240),
+    eventType: normalizeCameraEventType(meta.eventType),
+    scopeId: clampText(meta.scopeId, 160),
+    scopeName: clampText(meta.scopeName, 240),
+    objectTypes: uniqueTexts(Array.isArray(meta.objectTypes) ? meta.objectTypes : []).map(normalizeSearchText).filter(Boolean),
+    eventId: clampText(meta.eventId, 160),
+    active: meta.active !== false,
+    at: clampText(meta.at || new Date().toISOString(), 64),
+    raw: meta.raw
+  }
+}
+
+const cameraWatchMatchesEvent = (watch, event) => {
+  if (!watch || !event) return false
+  const watchCameraId = clampText(watch.cameraId, 160)
+  const eventCameraId = clampText(event.cameraId, 160)
+  if (watchCameraId && eventCameraId && watchCameraId !== eventCameraId) return false
+  if ((!watchCameraId || !eventCameraId) && normalizeSearchText(watch.cameraName) !== normalizeSearchText(event.cameraName)) return false
+  const wantedObjects = (Array.isArray(watch.objectTypes) ? watch.objectTypes : []).map(normalizeCameraObjectType).filter(Boolean)
+  const watchEventType = normalizeCameraEventType(watch.eventType)
+  const eventType = normalizeCameraEventType(event.eventType)
+  const genericSmartDetection = watchEventType === 'smartDetect'
+    || (watchEventType === 'motion' && wantedObjects.length > 0)
+  if (genericSmartDetection) {
+    if (!['smartDetectZone', 'smartDetectLine', 'smartDetectLoiterZone'].includes(eventType)) return false
+  } else if (watchEventType && watchEventType !== eventType) return false
+  const watchScope = normalizeSearchText(watch.scopeId || watch.scopeName)
+  const eventScopeCandidates = [event.scopeId, event.scopeName].map(normalizeSearchText).filter(Boolean)
+  if (watchScope && !eventScopeCandidates.some(candidate => candidate === watchScope || candidate.includes(watchScope) || watchScope.includes(candidate))) return false
+  if (wantedObjects.length) {
+    const detectedObjects = (Array.isArray(event.objectTypes) ? event.objectTypes : []).map(normalizeCameraObjectType).filter(Boolean)
+    if (!detectedObjects.some(type => wantedObjects.includes(type))) return false
+  }
+  return true
+}
+
+const normalizeKnxAiCameraImage = ({ data, mediaType } = {}) => {
+  if (!Buffer.isBuffer(data)) throw new Error('The camera snapshot is not binary image data')
+  if (data.length === 0) throw new Error('The camera snapshot is empty')
+  if (data.length > KNX_AI_CAMERA_IMAGE_MAX_BYTES) throw new Error(`The camera snapshot exceeds ${KNX_AI_CAMERA_IMAGE_MAX_BYTES} bytes`)
+  const type = clampText(mediaType || 'image/jpeg', 80).toLocaleLowerCase().split(';')[0]
+  if (!['image/jpeg', 'image/png', 'image/webp', 'image/gif'].includes(type)) throw new Error(`Unsupported camera image type: ${type}`)
+  return { data, mediaType: type, bytes: data.length }
+}
+
+const buildKnxAiCameraNotificationText = ({ language, event } = {}) => {
+  const lang = clampText(language || 'en', 8).toLocaleLowerCase()
+  const camera = clampText(event && event.cameraName, 240) || clampText(event && event.cameraId, 160) || 'camera'
+  const eventType = normalizeCameraEventType(event && event.eventType)
+  const scope = clampText(event && (event.scopeName || event.scopeId), 240)
+  const objectTypes = uniqueTexts(event && event.objectTypes).join(', ')
+  const details = [scope, objectTypes].filter(Boolean).join(' — ')
+  const suffix = details ? ` (${details})` : ''
+  const labels = {
+    it: { smartDetectLine: 'un attraversamento di linea', smartDetectZone: 'un ingresso in zona', smartDetectLoiterZone: 'una permanenza in zona', motion: 'un movimento', ring: 'un suono del campanello', smartAudioDetect: 'un evento audio intelligente' },
+    de: { smartDetectLine: 'eine Linienüberquerung', smartDetectZone: 'einen Zoneneintritt', smartDetectLoiterZone: 'einen längeren Zonenaufenthalt', motion: 'eine Bewegung', ring: 'ein Klingeln', smartAudioDetect: 'ein intelligentes Audioereignis' },
+    fr: { smartDetectLine: 'un franchissement de ligne', smartDetectZone: 'une entrée dans une zone', smartDetectLoiterZone: 'une présence prolongée dans une zone', motion: 'un mouvement', ring: 'une sonnerie', smartAudioDetect: 'un événement audio intelligent' },
+    es: { smartDetectLine: 'un cruce de línea', smartDetectZone: 'una entrada en zona', smartDetectLoiterZone: 'una permanencia en zona', motion: 'un movimiento', ring: 'una llamada al timbre', smartAudioDetect: 'un evento de audio inteligente' },
+    zh: { smartDetectLine: '越线事件', smartDetectZone: '进入区域事件', smartDetectLoiterZone: '区域徘徊事件', motion: '移动事件', ring: '门铃事件', smartAudioDetect: '智能音频事件' },
+    en: { smartDetectLine: 'a line crossing', smartDetectZone: 'a zone entry', smartDetectLoiterZone: 'loitering in a zone', motion: 'motion', ring: 'a doorbell ring', smartAudioDetect: 'a smart audio event' }
+  }
+  const label = (labels[lang] || labels.en)[eventType] || (lang === 'zh' ? '摄像机事件' : lang === 'it' ? 'un evento' : lang === 'de' ? 'ein Ereignis' : lang === 'fr' ? 'un événement' : lang === 'es' ? 'un evento' : 'an event')
+  const copy = {
+    it: `La telecamera ${camera} ha rilevato ${label}${suffix}.`,
+    de: `Die Kamera ${camera} hat ${label} erkannt${suffix}.`,
+    fr: `La caméra ${camera} a détecté ${label}${suffix}.`,
+    es: `La cámara ${camera} ha detectado ${label}${suffix}.`,
+    zh: `摄像机 ${camera} 检测到${label}${suffix}。`,
+    en: `Camera ${camera} detected ${label}${suffix}.`
+  }
+  return copy[lang] || copy.en
+}
+
+module.exports = {
+  KNX_AI_CAMERA_IMAGE_MAX_BYTES,
+  KNX_AI_CAMERA_MAX_ACTIONS,
+  KNX_AI_CAMERA_REGISTRY_KEY,
+  buildKnxAiCameraNotificationText,
+  cameraWatchMatchesEvent,
+  getKnxAiCameraAdapterRegistry,
+  normalizeCameraEventType,
+  normalizeCameraObjectType,
+  normalizeKnxAiCameraAction,
+  normalizeKnxAiCameraActions,
+  normalizeKnxAiCameraEvent,
+  normalizeKnxAiCameraImage,
+  normalizeKnxAiCameraRegistration,
+  normalizeSearchText,
+  resolveKnxAiCamera
+}