node-red-contrib-knx-ultimate 6.1.1 → 6.2.1

package/nodes/knxUltimateAI.js

@@ -5,6 +5,23 @@ const fs = require('fs')
 const path = require('path')
 const { spawn } = require('child_process')
 const { getRequestAccessToken, normalizeAuthFromAccessTokenQuery } = require('./utils/httpAdminAccessToken')
+const {
+  HOME_MEMORY_MAX_EDUCATION_CHARS,
+  HOME_MEMORY_MAX_SEMANTIC_OBJECTS,
+  addBoundedKnxAiNotification,
+  addBoundedKnxAiObservation,
+  buildKnxAiHomeMemoryMarkdown,
+  buildKnxAiProactiveFallback,
+  clampHomeMemoryKb,
+  classifyKnxAiOpenState,
+  createEmptyKnxAiHomeMemory,
+  enrichKnxAiHomeCatalog,
+  isKnxAiQuietTime,
+  normalizeKnxAiHomeMemory,
+  normalizeHomeLanguage,
+  parseKnxAiHomeMemoryMarkdown,
+  updateKnxAiCoverHabit
+} = require('./utils/knxAiHomeMemory')
 let googleTranslateTTS = null
 try {
   googleTranslateTTS = require('google-translate-tts')
@@ -738,6 +755,626 @@ const extractJsonFragmentFromText = (value) => {
   throw new Error(`The LLM response did not contain valid JSON${preview ? ` (preview: ${preview})` : ''}`)
 }
 
+const parseKnxAiConversationResponse = (value) => {
+  const parsed = extractJsonFragmentFromText(value)
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    throw new Error('The LLM conversation response must be a JSON object')
+  }
+  const reply = String(parsed.reply !== undefined
+    ? parsed.reply
+    : parsed.answer !== undefined
+      ? parsed.answer
+      : parsed.text !== undefined
+        ? parsed.text
+        : '').trim()
+  const commands = Array.isArray(parsed.commands)
+    ? parsed.commands
+    : Array.isArray(parsed.actions)
+      ? parsed.actions
+      : []
+  const language = String(parsed.language !== undefined
+    ? parsed.language
+    : parsed.locale !== undefined
+      ? parsed.locale
+      : '').trim()
+  return { reply, commands, language }
+}
+
+const extractKnxAiQuestion = (msg) => {
+  const source = msg && typeof msg === 'object' ? msg : {}
+  if (source.prompt !== undefined && source.prompt !== null) return String(source.prompt).trim()
+  if (typeof source.payload === 'string') return source.payload.trim()
+  if (source.payload && typeof source.payload === 'object') {
+    if (typeof source.payload.content === 'string') return source.payload.content.trim()
+    if (typeof source.payload.text === 'string') return source.payload.text.trim()
+    if (source.payload.message && typeof source.payload.message.text === 'string') return source.payload.message.text.trim()
+  }
+  if (source.originalMessage && typeof source.originalMessage === 'object') {
+    if (typeof source.originalMessage.text === 'string') return source.originalMessage.text.trim()
+    if (source.originalMessage.message && typeof source.originalMessage.message.text === 'string') return source.originalMessage.message.text.trim()
+  }
+  return source.payload === undefined ? '' : safeStringify(source.payload)
+}
+
+const resolveKnxAiSessionId = (msg) => {
+  const source = msg && typeof msg === 'object' ? msg : {}
+  const candidates = [
+    source.knxAi && source.knxAi.sessionId,
+    source.sessionId,
+    source.chatId,
+    source.payload && typeof source.payload === 'object' ? source.payload.chatId : '',
+    source.payload && source.payload.chat && typeof source.payload.chat === 'object' ? source.payload.chat.id : '',
+    source.originalMessage && source.originalMessage.chat ? source.originalMessage.chat.id : '',
+    source.originalMessage && source.originalMessage.message && source.originalMessage.message.chat
+      ? source.originalMessage.message.chat.id
+      : ''
+  ]
+  const hit = candidates.find(candidate => candidate !== undefined && candidate !== null && String(candidate).trim() !== '')
+  return String(hit === undefined ? 'default' : hit).trim().slice(0, 160) || 'default'
+}
+
+const classifyKnxAiConfirmation = ({ msg, question, topic } = {}) => {
+  const source = msg && typeof msg === 'object' ? msg : {}
+  if (source.knxAi && source.knxAi.confirm === true) return 'confirm'
+  if (source.knxAi && source.knxAi.confirm === false) return 'cancel'
+  const topicValue = String(topic || '').trim().toLowerCase()
+  if (topicValue === 'confirm') return 'confirm'
+  if (topicValue === 'cancel') return 'cancel'
+  const normalized = String(question || '')
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .trim()
+    .toLowerCase()
+    .replace(/[.!?。！？]+$/g, '')
+    .replace(/\s+/g, ' ')
+  const confirmations = new Set([
+    'confirm', 'confirmed', 'yes', 'y', 'ok', 'proceed',
+    'conferma', 'confermo', 'si', 'procedi',
+    'confirmer', 'confirme', 'oui',
+    'bestatigen', 'bestatige', 'ja',
+    'confirmar', 'confirmo', 'adelante',
+    '确认', '是'
+  ])
+  const cancellations = new Set([
+    'cancel', 'cancelled', 'no', 'n', 'stop',
+    'annulla', 'annullo', 'no grazie',
+    'annuler', 'annule', 'non',
+    'abbrechen', 'abbruch', 'nein',
+    'cancelar', 'cancelo',
+    '取消', '否'
+  ])
+  if (confirmations.has(normalized)) return 'confirm'
+  if (cancellations.has(normalized)) return 'cancel'
+  return 'none'
+}
+
+const detectKnxAiLanguageFromText = (value) => {
+  const raw = String(value || '').trim()
+  if (!raw) return ''
+  if (/[\u3400-\u9fff]/u.test(raw)) return 'zh'
+  const normalized = raw
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+  const tokens = new Set(normalized.match(/[a-z]+/g) || [])
+  const dictionaries = {
+    it: ['accendi', 'spegni', 'luce', 'luci', 'soggiorno', 'cucina', 'apri', 'chiudi', 'alza', 'abbassa', 'tapparella', 'tapparelle'],
+    en: ['turn', 'switch', 'light', 'lights', 'living', 'room', 'kitchen', 'open', 'close', 'raise', 'lower', 'blind', 'blinds'],
+    de: ['schalte', 'licht', 'lichter', 'wohnzimmer', 'kuche', 'offne', 'schliesse', 'hoch', 'runter', 'rollladen'],
+    fr: ['allume', 'eteins', 'lumiere', 'lumieres', 'salon', 'cuisine', 'ouvre', 'ferme', 'monte', 'baisse', 'volet'],
+    es: ['enciende', 'apaga', 'luz', 'luces', 'salon', 'cocina', 'abre', 'cierra', 'sube', 'baja', 'persiana']
+  }
+  const scores = Object.entries(dictionaries).map(([language, words]) => ({
+    language,
+    score: words.reduce((total, word) => total + (tokens.has(word) ? 1 : 0), 0)
+  })).sort((a, b) => b.score - a.score)
+  if (!scores[0] || scores[0].score === 0) return ''
+  if (scores[1] && scores[0].score === scores[1].score) return ''
+  return scores[0].language
+}
+
+const resolveKnxAiLanguage = (msg, fallback = 'en', question = '', responseLanguage = '') => {
+  const source = msg && typeof msg === 'object' ? msg : {}
+  const explicitCandidates = [
+    source.knxAi && source.knxAi.language,
+    source.language,
+    source.payload && typeof source.payload === 'object' ? source.payload.language : ''
+  ]
+  const inferredCandidates = [
+    responseLanguage,
+    detectKnxAiLanguageFromText(question),
+    source.originalMessage && source.originalMessage.from ? source.originalMessage.from.language_code : '',
+    source.originalMessage && source.originalMessage.message && source.originalMessage.message.from
+      ? source.originalMessage.message.from.language_code
+      : ''
+  ]
+  const supported = new Set(['en', 'it', 'de', 'fr', 'es', 'zh'])
+  for (const candidate of explicitCandidates.concat(inferredCandidates)) {
+    if (candidate === undefined || candidate === null || String(candidate).trim() === '') continue
+    const language = normalizeLanguageCode(candidate, '')
+    if (supported.has(language)) return language
+  }
+  const fallbackLanguage = normalizeLanguageCode(fallback, 'en')
+  return supported.has(fallbackLanguage) ? fallbackLanguage : 'en'
+}
+
+const getKnxAiConfirmationCopy = (language) => {
+  const copies = {
+    en: {
+      preview: 'KNX changes awaiting confirmation',
+      instruction: 'Reply exactly CONFIRM to proceed or CANCEL to discard them. The request expires in 5 minutes.',
+      confirmLabel: 'Confirm',
+      cancelLabel: 'Cancel',
+      confirmed: count => `Confirmed: ${count} KNX command(s) forwarded to the flow. Execution still requires KNX status feedback.`,
+      cancelled: 'Cancelled: no KNX command was sent.',
+      expired: 'The pending KNX command request has expired. Please repeat the original request.',
+      missing: 'There is no KNX command request awaiting confirmation.',
+      invalid: details => `The pending KNX commands are no longer valid and were not sent: ${details}.`
+    },
+    it: {
+      preview: 'Modifiche KNX in attesa di conferma',
+      instruction: 'Rispondi esattamente CONFERMA per procedere oppure ANNULLA per eliminarle. La richiesta scade tra 5 minuti.',
+      confirmLabel: 'Conferma',
+      cancelLabel: 'Annulla',
+      confirmed: count => `Confermato: ${count} comando/i KNX inoltrato/i al flow. L'esecuzione deve comunque essere verificata tramite lo stato KNX.`,
+      cancelled: 'Annullato: non è stato inviato alcun comando KNX.',
+      expired: 'La richiesta di comandi KNX è scaduta. Ripeti la richiesta originale.',
+      missing: 'Non ci sono comandi KNX in attesa di conferma.',
+      invalid: details => `I comandi KNX in attesa non sono più validi e non sono stati inviati: ${details}.`
+    },
+    de: {
+      preview: 'KNX-Änderungen warten auf Bestätigung',
+      instruction: 'Antworte genau mit BESTÄTIGEN oder ABBRECHEN. Die Anfrage läuft nach 5 Minuten ab.',
+      confirmLabel: 'Bestätigen',
+      cancelLabel: 'Abbrechen',
+      confirmed: count => `Bestätigt: ${count} KNX-Befehl(e) an den Flow weitergegeben. Die Ausführung muss über KNX-Statusfeedback geprüft werden.`,
+      cancelled: 'Abgebrochen: Es wurde kein KNX-Befehl gesendet.',
+      expired: 'Die ausstehende KNX-Anfrage ist abgelaufen. Bitte die ursprüngliche Anfrage wiederholen.',
+      missing: 'Es wartet keine KNX-Anfrage auf Bestätigung.',
+      invalid: details => `Die ausstehenden KNX-Befehle sind nicht mehr gültig und wurden nicht gesendet: ${details}.`
+    },
+    fr: {
+      preview: 'Modifications KNX en attente de confirmation',
+      instruction: 'Répondez exactement CONFIRMER pour continuer ou ANNULER pour abandonner. La demande expire dans 5 minutes.',
+      confirmLabel: 'Confirmer',
+      cancelLabel: 'Annuler',
+      confirmed: count => `Confirmé : ${count} commande(s) KNX transmise(s) au flow. L'exécution doit encore être vérifiée par un retour d'état KNX.`,
+      cancelled: 'Annulé : aucune commande KNX n’a été envoyée.',
+      expired: 'La demande de commandes KNX a expiré. Répétez la demande initiale.',
+      missing: 'Aucune commande KNX n’est en attente de confirmation.',
+      invalid: details => `Les commandes KNX en attente ne sont plus valides et n’ont pas été envoyées : ${details}.`
+    },
+    es: {
+      preview: 'Cambios KNX pendientes de confirmación',
+      instruction: 'Responde exactamente CONFIRMAR para continuar o CANCELAR para descartarlos. La solicitud caduca en 5 minutos.',
+      confirmLabel: 'Confirmar',
+      cancelLabel: 'Cancelar',
+      confirmed: count => `Confirmado: ${count} comando(s) KNX enviado(s) al flow. La ejecución aún debe verificarse mediante el estado KNX.`,
+      cancelled: 'Cancelado: no se envió ningún comando KNX.',
+      expired: 'La solicitud de comandos KNX ha caducado. Repite la solicitud original.',
+      missing: 'No hay comandos KNX pendientes de confirmación.',
+      invalid: details => `Los comandos KNX pendientes ya no son válidos y no se enviaron: ${details}.`
+    },
+    zh: {
+      preview: '等待确认的 KNX 更改',
+      instruction: '请准确回复“确认”以继续，或回复“取消”以放弃。请求将在 5 分钟后过期。',
+      confirmLabel: '确认',
+      cancelLabel: '取消',
+      confirmed: count => `已确认：${count} 条 KNX 命令已转发到 flow。仍需通过 KNX 状态反馈确认执行结果。`,
+      cancelled: '已取消：未发送任何 KNX 命令。',
+      expired: '待处理的 KNX 命令请求已过期，请重新发送原始请求。',
+      missing: '当前没有等待确认的 KNX 命令。',
+      invalid: details => `待处理的 KNX 命令已失效，未发送：${details}。`
+    }
+  }
+  return copies[language] || copies.en
+}
+
+const getKnxAiReadCopy = (language) => {
+  const copies = {
+    en: {
+      heading: 'Updated KNX readings',
+      noResponse: 'The KNX read request was sent, but no device replied within the timeout.',
+      partial: 'No response received for'
+    },
+    it: {
+      heading: 'Letture KNX aggiornate',
+      noResponse: 'La richiesta di lettura KNX è stata inviata, ma nessun dispositivo ha risposto entro il timeout.',
+      partial: 'Nessuna risposta ricevuta per'
+    },
+    de: {
+      heading: 'Aktualisierte KNX-Messwerte',
+      noResponse: 'Die KNX-Leseanfrage wurde gesendet, aber innerhalb des Timeouts hat kein Gerät geantwortet.',
+      partial: 'Keine Antwort erhalten für'
+    },
+    fr: {
+      heading: 'Lectures KNX actualisées',
+      noResponse: 'La demande de lecture KNX a été envoyée, mais aucun appareil n’a répondu avant l’expiration du délai.',
+      partial: 'Aucune réponse reçue pour'
+    },
+    es: {
+      heading: 'Lecturas KNX actualizadas',
+      noResponse: 'La solicitud de lectura KNX se envió, pero ningún dispositivo respondió antes de agotarse el tiempo.',
+      partial: 'No se recibió respuesta para'
+    },
+    zh: {
+      heading: '已更新的 KNX 读数',
+      noResponse: 'KNX 读取请求已发送，但在超时前没有设备响应。',
+      partial: '未收到响应'
+    }
+  }
+  return copies[language] || copies.en
+}
+
+const formatKnxAiReadResults = ({ operations, results, language }) => {
+  const reads = Array.isArray(operations) ? operations : []
+  const settled = Array.isArray(results) ? results : []
+  const copy = getKnxAiReadCopy(language)
+  const values = []
+  const missing = []
+  reads.forEach((operation, index) => {
+    const result = settled[index]
+    const label = String(operation && (operation.label || operation.destination) ? (operation.label || operation.destination) : '').trim()
+    if (!result || result.status !== 'fulfilled' || !result.value) {
+      missing.push(label || String(operation && operation.destination ? operation.destination : '').trim())
+      return
+    }
+    const telegram = result.value
+    const rawValue = telegram.payload
+    const value = rawValue && typeof rawValue === 'object' ? safeStringify(rawValue) : String(rawValue)
+    const unit = String(telegram.payloadmeasureunit || '').trim()
+    values.push(`- ${label || operation.destination}: ${value}${unit ? ` ${unit}` : ''}`)
+  })
+  if (values.length === 0) return copy.noResponse
+  const lines = [`${copy.heading}:`, ...values]
+  if (missing.length > 0) lines.push('', `${copy.partial}: ${missing.filter(Boolean).join(', ')}.`)
+  return lines.join('\n')
+}
+
+const buildKnxAiConfirmationRequest = ({
+  sessionId,
+  expiresAt,
+  commandCount,
+  copy
+}) => {
+  const resolvedSessionId = String(sessionId || 'default')
+  const resolvedExpiresAt = Number(expiresAt || 0)
+  const buildAction = ({ id, label, confirm }) => ({
+    id,
+    label,
+    callbackData: id,
+    message: {
+      topic: id,
+      knxAi: {
+        confirm,
+        sessionId: resolvedSessionId
+      }
+    }
+  })
+  return {
+    required: true,
+    status: 'pending',
+    sessionId: resolvedSessionId,
+    expiresAt: resolvedExpiresAt,
+    expiresAtIso: resolvedExpiresAt > 0 ? new Date(resolvedExpiresAt).toISOString() : '',
+    commandCount: Math.max(0, Number(commandCount) || 0),
+    actions: [
+      buildAction({ id: 'confirm', label: copy.confirmLabel, confirm: true }),
+      buildAction({ id: 'cancel', label: copy.cancelLabel, confirm: false })
+    ]
+  }
+}
+
+const cloneKnxAiInputMessage = (inputMessage, cloneMessage, onError) => {
+  const source = inputMessage && typeof inputMessage === 'object' ? inputMessage : {}
+  if (typeof cloneMessage === 'function') {
+    try {
+      const cloned = cloneMessage(source)
+      if (cloned && typeof cloned === 'object') return cloned
+    } catch (error) {
+      try {
+        if (typeof onError === 'function') onError(error)
+      } catch (reportError) {
+        // Reporting a clone error must never propagate to the Node-RED runtime.
+      }
+      // Fall back to a shallow copy if a custom message property cannot be cloned.
+    }
+  }
+  try {
+    return Object.assign({}, source)
+  } catch (error) {
+    try {
+      if (typeof onError === 'function') onError(error)
+    } catch (reportError) {
+      // Reporting a clone error must never propagate to the Node-RED runtime.
+    }
+    return {}
+  }
+}
+
+const safeKnxAiSend = ({ outputs, send, onError }) => {
+  try {
+    if (typeof send !== 'function') throw new Error('KNX AI output sender is unavailable')
+    send(outputs)
+    return true
+  } catch (error) {
+    try {
+      if (typeof onError === 'function') onError(error)
+    } catch (reportError) {
+      // Reporting an output error must never propagate to the Node-RED runtime.
+    }
+    return false
+  }
+}
+
+const compileKnxAiChatAdapter = ({ code, direction = 'chat' } = {}) => {
+  const source = String(code || '').trim()
+  if (!source) return null
+  const adapterDirection = String(direction || 'chat').trim() || 'chat'
+  try {
+    return {
+      direction: adapterDirection,
+      run: new Function('msg', 'inputMessage', 'node', 'RED', `"use strict";\n${source}`) // eslint-disable-line no-new-func
+    }
+  } catch (error) {
+    throw new Error(`Invalid KNX AI ${adapterDirection} adapter: ${error.message || error}`)
+  }
+}
+
+const executeKnxAiChatAdapter = ({
+  adapter,
+  msg,
+  inputMessage,
+  node,
+  RED
+} = {}) => {
+  if (!adapter || typeof adapter.run !== 'function') return msg
+  const result = adapter.run(msg, inputMessage, node, RED)
+  if (result && typeof result.then === 'function') {
+    throw new Error(`KNX AI ${adapter.direction || 'chat'} adapter must be synchronous`)
+  }
+  if (result === undefined || result === null) return null
+  if (!result || typeof result !== 'object' || Array.isArray(result)) {
+    throw new Error(`KNX AI ${adapter.direction || 'chat'} adapter must return msg or no value`)
+  }
+  return result
+}
+
+const buildKnxAiUniversalMessage = ({
+  command,
+  question,
+  sessionId,
+  confirmed,
+  index,
+  inputMessage
+}) => {
+  const operation = command && typeof command === 'object' ? command : {}
+  const event = operation.event === 'GroupValue_Read' ? 'GroupValue_Read' : 'GroupValue_Write'
+  const outputMessage = {
+    topic: operation.destination,
+    destination: operation.destination,
+    dpt: operation.dpt,
+    payload: event === 'GroupValue_Read' ? '' : operation.payload,
+    event,
+    inputMessage,
+    knxAi: {
+      type: event === 'GroupValue_Read' ? 'knx_read' : 'knx_command',
+      source: 'llm',
+      question,
+      sessionId,
+      confirmed: event === 'GroupValue_Write' && confirmed === true,
+      index,
+      label: operation.label || '',
+      reason: operation.reason || ''
+    }
+  }
+  if (event === 'GroupValue_Read') outputMessage.readstatus = true
+  return outputMessage
+}
+
+const formatKnxAiCommandPreview = ({ commands, copy }) => {
+  const lines = (Array.isArray(commands) ? commands : []).map((command, index) => {
+    const payload = typeof command.payload === 'string' ? command.payload : safeStringify(command.payload)
+    return `${index + 1}. ${command.label || command.destination} — ${command.destination} / DPT ${command.dpt} → ${payload}`
+  })
+  return [
+    copy.preview + ':',
+    ...lines,
+    '',
+    copy.instruction
+  ].join('\n')
+}
+
+const validateKnxAiPayloadForDpt = ({ dpt, payload }) => {
+  const resolved = dptlib.resolve(dpt)
+  const base = resolved && resolved.basetype ? resolved.basetype : {}
+  const subtype = resolved && resolved.subtype ? resolved.subtype : {}
+  const main = String(dpt || '').split('.')[0]
+
+  if (base.valuetype === 'composite' && (!payload || typeof payload !== 'object' || Array.isArray(payload))) {
+    throw new Error(`DPT ${dpt} requires an object payload`)
+  }
+  if (main === '1' && typeof payload !== 'boolean') {
+    throw new Error(`DPT ${dpt} requires a boolean payload`)
+  }
+  if (main === '3') {
+    const direction = Number(payload && payload.decr_incr)
+    const data = Number(payload && payload.data)
+    if (![0, 1].includes(direction) || !Number.isInteger(data) || data < 0 || data > 7) {
+      throw new Error(`DPT ${dpt} requires {decr_incr:0|1,data:0..7}`)
+    }
+  }
+  if (main === '232') {
+    const channels = ['red', 'green', 'blue'].map(key => Number(payload && payload[key]))
+    if (channels.some(value => !Number.isInteger(value) || value < 0 || value > 255)) {
+      throw new Error(`DPT ${dpt} requires {red,green,blue} values from 0 to 255`)
+    }
+  }
+
+  if (typeof payload === 'number') {
+    const candidateRange = Array.isArray(subtype.scalar_range) && subtype.scalar_range.length === 2
+      ? subtype.scalar_range
+      : Array.isArray(subtype.range) && subtype.range.length === 2
+        ? subtype.range
+        : Array.isArray(base.range) && base.range.length === 2
+          ? base.range
+          : null
+    if (candidateRange && Number.isFinite(Number(candidateRange[0])) && Number.isFinite(Number(candidateRange[1]))) {
+      const min = Number(candidateRange[0])
+      const max = Number(candidateRange[1])
+      if (payload < min || payload > max) throw new Error(`DPT ${dpt} payload must be between ${min} and ${max}`)
+    }
+  }
+
+  if (subtype.enc && typeof subtype.enc === 'object' && !Array.isArray(subtype.enc) && main !== '1') {
+    const allowed = new Set(Object.keys(subtype.enc).map(key => String(key)))
+    if (!allowed.has(String(payload))) throw new Error(`DPT ${dpt} payload is not an allowed enumerated value`)
+  }
+
+  if (resolved && typeof resolved.formatAPDU === 'function') resolved.formatAPDU(payload)
+  return payload
+}
+
+const coerceKnxAiCommandPayload = (value, { dpt } = {}) => {
+  const dptId = String(dpt || '').trim()
+  const parsed = parseActuatorPayloadInput(value)
+  const main = dptId.split('.')[0]
+  if (main === '1') {
+    if (parsed === true || parsed === false) return parsed
+    if (parsed === 1) return true
+    if (parsed === 0) return false
+    const rawBoolean = typeof parsed === 'string' ? parsed.trim() : String(parsed)
+    const normalized = rawBoolean.toLowerCase()
+    if (['true', '1', 'on'].includes(normalized)) return true
+    if (['false', '0', 'off'].includes(normalized)) return false
+    const normalizedLabel = normalizeSignalText(rawBoolean)
+    const booleanOption = getDptValueOptions(dptId).find(item => {
+      return normalizeSignalText(item.label) === normalizedLabel
+    })
+    if (booleanOption) {
+      const optionValue = parseActuatorPayloadInput(booleanOption.value)
+      if (optionValue === true || optionValue === 1) return true
+      if (optionValue === false || optionValue === 0) return false
+    }
+    throw new Error(`DPT ${dptId} payload must be true/false, 1/0, on/off, or an exact ETS value label`)
+  }
+  if (typeof parsed !== 'string') return parsed
+  const raw = parsed.trim()
+  if (main === '16') return raw
+  const normalizedRaw = normalizeSignalText(raw)
+  const option = getDptValueOptions(dptId).find(item => {
+    return String(item.value) === raw || normalizeSignalText(item.label) === normalizedRaw
+  })
+  if (option) return parseActuatorPayloadInput(option.value)
+  throw new Error(`DPT ${dptId} payload must be a typed JSON value or an exact ETS value label`)
+}
+
+const resolveKnxAiOperationEvent = (candidate) => {
+  const item = candidate && typeof candidate === 'object' ? candidate : {}
+  const raw = String(item.event || item.operation || item.action || '').trim().toLowerCase()
+  if (['groupvalue_read', 'read', 'query', 'request_status'].includes(raw)) return 'GroupValue_Read'
+  return 'GroupValue_Write'
+}
+
+const normalizeKnxAiCommandCandidates = ({
+  commands,
+  catalog,
+  maxCommands = 5,
+  maxReadCommands = 20,
+  coercePayload = value => value
+} = {}) => {
+  const sourceCommands = Array.isArray(commands) ? commands : []
+  const safeCatalog = Array.isArray(catalog) ? catalog : []
+  const catalogByGa = new Map(safeCatalog.map(item => [String(item && item.ga ? item.ga : '').trim(), item]))
+  const accepted = []
+  const rejected = []
+  const writeLimit = Math.max(1, Math.min(20, Number(maxCommands) || 5))
+  const readLimit = Math.max(1, Math.min(50, Number(maxReadCommands) || 20))
+  const totalLimit = writeLimit + readLimit
+  let acceptedWrites = 0
+  let acceptedReads = 0
+  let writeLimitReported = false
+  let readLimitReported = false
+
+  sourceCommands.slice(0, totalLimit).forEach((candidate, index) => {
+    try {
+      const item = candidate && typeof candidate === 'object' ? candidate : {}
+      const event = resolveKnxAiOperationEvent(item)
+      const destination = String(item.destination || item.ga || item.groupAddress || item.address || '').trim()
+      if (!destination) throw new Error('missing destination')
+      const catalogItem = catalogByGa.get(destination)
+      if (!catalogItem) throw new Error('destination is not present in the imported ETS catalog')
+      if (event === 'GroupValue_Write' && String(catalogItem.role || '').trim().toLowerCase() !== 'command') {
+        throw new Error('destination is not classified as a command group address')
+      }
+      const catalogDpt = String(catalogItem.dpt || '').trim()
+      if (!catalogDpt) throw new Error('the ETS catalog has no DPT for this destination')
+      const requestedDpt = String(item.dpt || '').trim()
+      if (requestedDpt && requestedDpt !== catalogDpt) {
+        throw new Error(`requested DPT ${requestedDpt} does not match ETS DPT ${catalogDpt}`)
+      }
+      if (event === 'GroupValue_Read') {
+        if (acceptedReads >= readLimit) {
+          if (readLimitReported) return
+          readLimitReported = true
+          throw new Error(`read limit exceeded (${readLimit})`)
+        }
+        acceptedReads += 1
+        accepted.push({
+          destination,
+          dpt: catalogDpt,
+          payload: '',
+          readstatus: true,
+          event,
+          label: String(catalogItem.label || destination).trim(),
+          reason: String(item.reason || '').trim(),
+          sourceIndex: index
+        })
+        return
+      }
+      if (acceptedWrites >= writeLimit) {
+        if (writeLimitReported) return
+        writeLimitReported = true
+        throw new Error(`command limit exceeded (${writeLimit})`)
+      }
+      const hasPayload = Object.prototype.hasOwnProperty.call(item, 'payload') || Object.prototype.hasOwnProperty.call(item, 'value')
+      if (!hasPayload) throw new Error('missing payload')
+      const rawPayload = Object.prototype.hasOwnProperty.call(item, 'payload') ? item.payload : item.value
+      const payload = coercePayload(rawPayload, {
+        dpt: catalogDpt,
+        action: item.action,
+        reason: item.reason,
+        label: catalogItem.label,
+        destination
+      })
+      validateKnxAiPayloadForDpt({ dpt: catalogDpt, payload })
+      acceptedWrites += 1
+      accepted.push({
+        destination,
+        dpt: catalogDpt,
+        payload,
+        event: 'GroupValue_Write',
+        label: String(catalogItem.label || destination).trim(),
+        reason: String(item.reason || '').trim(),
+        sourceIndex: index
+      })
+    } catch (error) {
+      rejected.push({
+        sourceIndex: index,
+        reason: error && error.message ? error.message : String(error)
+      })
+    }
+  })
+
+  if (sourceCommands.length > totalLimit) {
+    rejected.push({
+      sourceIndex: totalLimit,
+      reason: `operation limit exceeded (${totalLimit})`
+    })
+  }
+  return { accepted, rejected }
+}
+
 const normalizeValueForCompare = (value) => {
   if (value === undefined) return 'undefined'
   if (value === null) return 'null'
@@ -2939,6 +3576,8 @@ const ensureOllamaServerRunning = async ({ baseUrl, autoStart = false, timeoutMs
 const isProbablyChatModelId = (id) => {
   const s = String(id || '').toLowerCase()
   if (!s) return false
+  if (s === 'babbage-002' || s === 'davinci-002') return false
+  if (s.includes('instruct')) return false
   if (s.includes('embedding')) return false
   if (s.includes('whisper')) return false
   if (s.includes('tts')) return false
@@ -2947,6 +3586,109 @@ const isProbablyChatModelId = (id) => {
   return true
 }
 
+const isChatCompletionsModelError = (value) => {
+  const message = String(value || '').toLowerCase()
+  return message.includes('not a chat model') ||
+    message.includes('not supported in the v1/chat/completions endpoint') ||
+    message.includes('only compatible with the legacy completions endpoint') ||
+    message.includes('not chat completions') ||
+    message.includes('does not support chat completions')
+}
+
+const decorateChatCompletionsModelError = ({ error, model, url }) => {
+  const originalMessage = String(error && error.message ? error.message : error || '').trim()
+  const selectedModel = String(model || '').trim() || '(empty)'
+  const endpoint = String(url || '').trim() || OPENAI_COMPAT_DEFAULT_CHAT_URL
+  const decorated = new Error(
+    `Model "${selectedModel}" is not compatible with the configured Chat Completions endpoint (${endpoint}). ` +
+    'Choose a chat-capable model, for example gpt-5.4 or gpt-4o-mini. ' +
+    `Legacy /v1/completions models are not supported by KNX AI.${originalMessage ? ` Provider response: ${originalMessage}` : ''}`
+  )
+  if (error && error.status !== undefined) decorated.status = error.status
+  if (error && error.response !== undefined) decorated.response = error.response
+  return decorated
+}
+
+const isUnsupportedTemperatureError = (value) => {
+  const message = String(value || '').toLowerCase()
+  return message.includes("unsupported value: 'temperature'") ||
+    message.includes('unsupported parameter: temperature') ||
+    (message.includes('temperature') && message.includes('only the default'))
+}
+
+const isResponseFormatCompatibilityError = (value) => {
+  const message = String(value || '')
+  return message.includes("Unsupported parameter: 'response_format'") ||
+    message.includes('Invalid schema for response_format') ||
+    message.includes('response_format') ||
+    message.includes('json_schema')
+}
+
+const postOpenAiCompatibleChatWithFallbacks = async ({
+  url,
+  headers,
+  body,
+  timeoutMs,
+  model,
+  post = postJson
+}) => {
+  let requestBody = Object.assign({}, body)
+  let lastError = null
+  const rejectedTokenParameters = new Set()
+  const hasOwn = key => Object.prototype.hasOwnProperty.call(requestBody, key)
+
+  for (let attempt = 0; attempt < 6; attempt++) {
+    try {
+      return await post({ url, headers, body: requestBody, timeoutMs })
+    } catch (error) {
+      lastError = error
+      const message = String(error && error.message ? error.message : '')
+
+      if (isChatCompletionsModelError(message)) {
+        throw decorateChatCompletionsModelError({ error, model, url })
+      }
+
+      if (isUnsupportedTemperatureError(message) && hasOwn('temperature')) {
+        requestBody = Object.assign({}, requestBody)
+        delete requestBody.temperature
+        continue
+      }
+
+      if (isResponseFormatCompatibilityError(message) && hasOwn('response_format')) {
+        requestBody = Object.assign({}, requestBody)
+        delete requestBody.response_format
+        continue
+      }
+
+      if (message.includes("Unsupported parameter: 'max_tokens'") && hasOwn('max_tokens')) {
+        rejectedTokenParameters.add('max_tokens')
+        const value = requestBody.max_tokens
+        requestBody = Object.assign({}, requestBody)
+        delete requestBody.max_tokens
+        if (!rejectedTokenParameters.has('max_completion_tokens')) {
+          requestBody.max_completion_tokens = value
+          continue
+        }
+      }
+
+      if (message.includes("Unsupported parameter: 'max_completion_tokens'") && hasOwn('max_completion_tokens')) {
+        rejectedTokenParameters.add('max_completion_tokens')
+        const value = requestBody.max_completion_tokens
+        requestBody = Object.assign({}, requestBody)
+        delete requestBody.max_completion_tokens
+        if (!rejectedTokenParameters.has('max_tokens')) {
+          requestBody.max_tokens = value
+          continue
+        }
+      }
+
+      throw error
+    }
+  }
+
+  throw lastError || new Error('OpenAI-compatible chat request failed after compatibility retries')
+}
+
 module.exports = function (RED) {
   const flowGACache = { at: 0, set: new Set() }
   const flowNodeCatalogCache = { at: 0, catalog: null }
@@ -4306,6 +5048,19 @@ module.exports = function (RED) {
     node.llmDocsLanguage = config.llmDocsLanguage ? String(config.llmDocsLanguage) : 'it'
     node.llmDocsMaxSnippets = (config.llmDocsMaxSnippets === undefined || config.llmDocsMaxSnippets === '') ? 5 : Number(config.llmDocsMaxSnippets)
     node.llmDocsMaxChars = (config.llmDocsMaxChars === undefined || config.llmDocsMaxChars === '') ? 60000 : Number(config.llmDocsMaxChars)
+    node.llmAllowKnxCommands = config.llmAllowKnxCommands !== undefined ? coerceBoolean(config.llmAllowKnxCommands) : false
+    node.llmRequireCommandConfirmation = config.llmRequireCommandConfirmation !== undefined ? coerceBoolean(config.llmRequireCommandConfirmation) : true
+    node.chatAdapterPreset = String(config.chatAdapterPreset || 'none')
+    node.chatInputCode = String(config.chatInputCode || '')
+    node.chatOutputCode = String(config.chatOutputCode || '')
+    node.proactiveEnabled = config.proactiveEnabled !== undefined ? coerceBoolean(config.proactiveEnabled) : false
+    node.proactiveRecipient = String(config.proactiveRecipient || '').trim()
+    node.proactiveOpenMinutes = Math.max(1, Math.min(1440, Number(config.proactiveOpenMinutes) || 120))
+    node.proactiveCooldownMinutes = Math.max(5, Math.min(10080, Number(config.proactiveCooldownMinutes) || 360))
+    node.proactiveQuietStart = String(config.proactiveQuietStart || '23:00').trim()
+    node.proactiveQuietEnd = String(config.proactiveQuietEnd || '07:00').trim()
+    node.homeMemoryMaxKb = clampHomeMemoryKb(config.homeMemoryMaxKb)
+    node.aiEducation = String(config.aiEducation || '').slice(0, HOME_MEMORY_MAX_EDUCATION_CHARS)
 
     const pushStatus = (status) => {
       if (!status) return
@@ -4326,6 +5081,25 @@ module.exports = function (RED) {
       pushStatus(status)
     }
 
+    const compileConfiguredChatAdapter = ({ code, direction }) => {
+      try {
+        return compileKnxAiChatAdapter({ code, direction })
+      } catch (error) {
+        try { node.sysLogger?.error(`knxUltimateAI ${direction} adapter compile error: ${error.message || error}`) } catch (e) { /* ignore */ }
+        try { node.error(error) } catch (e) { /* ignore */ }
+        return null
+      }
+    }
+
+    node._chatInputAdapter = compileConfiguredChatAdapter({
+      code: node.chatInputCode,
+      direction: 'chat input'
+    })
+    node._chatOutputAdapter = compileConfiguredChatAdapter({
+      code: node.chatOutputCode,
+      direction: 'chat output'
+    })
+
     // Used to call the status update from the config node.
     node.setNodeStatus = ({ fill, shape, text, payload, GA, dpt, devicename }) => {
       try {
@@ -4357,6 +5131,8 @@ module.exports = function (RED) {
     node._summaryRebuildTimer = null
     node._anomalies = []
     node._assistantLog = []
+    node._conversationSessions = new Map()
+    node._pendingKnxCommands = new Map()
     node._flowContextCache = { at: 0, text: '' }
     node._docsContextCache = { at: 0, question: '', text: '' }
     node._areaSuggestionCache = { ref: null, snapshot: buildSuggestedAreasFromCsv([]) }
@@ -4371,6 +5147,16 @@ module.exports = function (RED) {
     node._gaLabelCsvCache = { ref: null, map: {} }
     node._busConnectionWatchTimer = null
     node._historyDiskLastPruneAt = 0
+    node._homeMemory = createEmptyKnxAiHomeMemory()
+    node._homeMemoryWriteTimer = null
+    node._homeMemoryPeriodicTimer = null
+    node._proactiveCheckTimer = null
+    node._proactiveStates = new Map()
+    node._proactiveInFlight = new Set()
+    node._proactiveGlobalSentAt = []
+    node._homeCatalogByGa = null
+    node._homeCatalogSnapshotRef = null
+    node._closing = false
     node._busConnectionState = (node.serverKNX && typeof node.serverKNX.linkStatus === 'string')
       ? String(node.serverKNX.linkStatus).toLowerCase()
       : 'unknown'
@@ -5483,6 +6269,7 @@ module.exports = function (RED) {
       const wantsFunctionNodeSourceContext = node.llmIncludeFlowContext && shouldIncludeFunctionNodeSourceContext(question)
       const areasSnapshot = buildAreasSnapshot({ summary })
       const areasContext = buildAreasPromptContext(areasSnapshot)
+      const homeMemoryContext = getHomeMemoryPromptContext({ maxChars: compactMode ? 2200 : 6000 })
       const summaryForPrompt = buildLlmSummarySnapshot(summary)
       const summaryText = truncatePromptText(safeStringify(summaryForPrompt), compactMode ? 4000 : 10000)
       const lines = recent.map(t => {
@@ -5564,6 +6351,8 @@ module.exports = function (RED) {
         '',
         areasContext || '',
         areasContext ? '' : '',
+        homeMemoryContext || '',
+        homeMemoryContext ? '' : '',
         flowContext ? 'Node-RED context:' : '',
         flowContext || '',
         flowContext ? '' : '',
@@ -5604,10 +6393,10 @@ module.exports = function (RED) {
       if (node._gaCatalogCache && node._gaCatalogCache.ref === csv && node._gaCatalogCache.roleOverridesKey === roleOverridesKey && Array.isArray(node._gaCatalogCache.snapshot)) {
         return node._gaCatalogCache.snapshot
       }
-      const snapshot = applyGaRoleOverridesToCatalog({
+      const snapshot = enrichKnxAiHomeCatalog(applyGaRoleOverridesToCatalog({
         catalog: buildGaCatalogFromCsv(csv),
         roleOverrides
-      })
+      }))
       node._gaCatalogCache = { ref: csv, roleOverridesKey, snapshot }
       return snapshot
     }
@@ -5635,6 +6424,147 @@ module.exports = function (RED) {
 
     const getHistoryArchiveFile = (dayKey) => path.join(getHistoryArchiveDir(), `${String(dayKey || '').trim() || formatArchiveDayKey(Date.now())}.jsonl`)
 
+    const getHomeMemoryFile = () => {
+      const baseDir = (node.serverKNX && node.serverKNX.userDir)
+        ? node.serverKNX.userDir
+        : path.join(RED.settings.userDir, 'knxultimatestorage')
+      return path.join(baseDir, 'knxai', 'memory', `knxai-home-memory-${node.id}.md`)
+    }
+
+    const cleanupHomeMemoryTempFiles = () => {
+      try {
+        const filePath = getHomeMemoryFile()
+        const dirPath = path.dirname(filePath)
+        if (!fs.existsSync(dirPath)) return
+        const prefix = `${path.basename(filePath)}.tmp-`
+        fs.readdirSync(dirPath)
+          .filter(name => String(name).startsWith(prefix))
+          .forEach(name => {
+            try { fs.unlinkSync(path.join(dirPath, name)) } catch (error) { /* ignore */ }
+          })
+      } catch (error) {
+        try { node.sysLogger?.warn(`KNX AI home memory temporary-file cleanup error: ${error.message || error}`) } catch (logError) { /* ignore */ }
+      }
+    }
+
+    const getHomeCatalogMap = () => {
+      const snapshot = getGaCatalogSnapshot()
+      if (node._homeCatalogSnapshotRef === snapshot && node._homeCatalogByGa instanceof Map) return node._homeCatalogByGa
+      node._homeCatalogSnapshotRef = snapshot
+      node._homeCatalogByGa = new Map(snapshot.map(item => [String(item && item.ga ? item.ga : '').trim(), item]))
+      return node._homeCatalogByGa
+    }
+
+    const synchronizeHomeMemorySemanticObjects = () => {
+      const semanticObjects = getGaCatalogSnapshot()
+        .filter(item => item && item.semantic && item.semantic.kind !== 'unknown')
+        .sort((a, b) => Number(b.semantic.confidence || 0) - Number(a.semantic.confidence || 0))
+        .slice(0, HOME_MEMORY_MAX_SEMANTIC_OBJECTS)
+        .map(item => ({
+          ga: item.ga,
+          dpt: item.dpt,
+          label: item.label || item.etsName || item.ga,
+          kind: item.semantic.kind,
+          area: item.semantic.area || '',
+          role: item.role || 'neutral',
+          confidence: Number(item.semantic.confidence || 0)
+        }))
+      node._homeMemory.semanticObjects = semanticObjects
+      node._homeMemory.updatedAt = new Date().toISOString()
+    }
+
+    const persistHomeMemoryNow = () => {
+      try {
+        synchronizeHomeMemorySemanticObjects()
+        const rendered = buildKnxAiHomeMemoryMarkdown({
+          memory: node._homeMemory,
+          education: node.aiEducation,
+          maxKb: node.homeMemoryMaxKb
+        })
+        node._homeMemory = rendered.memory
+        const filePath = getHomeMemoryFile()
+        const dirPath = path.dirname(filePath)
+        if (!ensureDirectorySync(dirPath)) throw new Error(`Unable to create ${dirPath}`)
+        const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`
+        try {
+          fs.writeFileSync(tempPath, rendered.markdown, 'utf8')
+          fs.renameSync(tempPath, filePath)
+        } catch (error) {
+          try { if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath) } catch (cleanupError) { /* ignore */ }
+          throw error
+        }
+        return {
+          filePath,
+          bytes: rendered.bytes,
+          maxBytes: rendered.maxBytes
+        }
+      } catch (error) {
+        try { node.sysLogger?.warn(`KNX AI home memory write error: ${error.message || error}`) } catch (logError) { /* ignore */ }
+        return null
+      }
+    }
+
+    const scheduleHomeMemoryPersist = ({ immediate = false } = {}) => {
+      if (node._homeMemoryWriteTimer) {
+        clearTimeout(node._homeMemoryWriteTimer)
+        node._homeMemoryWriteTimer = null
+      }
+      if (immediate) return persistHomeMemoryNow()
+      node._homeMemoryWriteTimer = setTimeout(() => {
+        node._homeMemoryWriteTimer = null
+        persistHomeMemoryNow()
+      }, 1500)
+      return null
+    }
+
+    const loadHomeMemoryFromDisk = () => {
+      const filePath = getHomeMemoryFile()
+      try {
+        cleanupHomeMemoryTempFiles()
+        if (!fs.existsSync(filePath)) {
+          node._homeMemory = createEmptyKnxAiHomeMemory()
+          return scheduleHomeMemoryPersist({ immediate: true })
+        }
+        const stat = fs.statSync(filePath)
+        const absoluteReadLimit = 4 * 1024 * 1024
+        if (Number(stat.size || 0) > absoluteReadLimit) {
+          throw new Error(`memory file exceeds the safe read limit (${absoluteReadLimit} bytes)`)
+        }
+        node._homeMemory = normalizeKnxAiHomeMemory(parseKnxAiHomeMemoryMarkdown(fs.readFileSync(filePath, 'utf8')))
+        return scheduleHomeMemoryPersist({ immediate: true })
+      } catch (error) {
+        node._homeMemory = createEmptyKnxAiHomeMemory()
+        try { node.sysLogger?.warn(`KNX AI home memory load error: ${error.message || error}`) } catch (logError) { /* ignore */ }
+        return scheduleHomeMemoryPersist({ immediate: true })
+      }
+    }
+
+    const getHomeMemoryPromptContext = ({ maxChars = 6000 } = {}) => {
+      const memory = normalizeKnxAiHomeMemory(node._homeMemory)
+      const education = String(node.aiEducation || '').trim().slice(0, HOME_MEMORY_MAX_EDUCATION_CHARS)
+      const habitLines = memory.habits.slice(-20).map(item => {
+        return `- ${item.label || item.ga}: average open ${Number(item.averageMinutes || 0).toFixed(1)} min (${Number(item.samples || 0)} samples), last ${Number(item.lastMinutes || 0).toFixed(1)} min`
+      })
+      const observationLines = memory.observations.slice(-20).map(item => {
+        return `- ${item.at || ''} ${item.label || item.ga || ''}: ${item.event || item.value || item.type || ''}`
+      })
+      const educationContext = [
+        'USER-MANAGED AI EDUCATION (authoritative; never rewrite or contradict it):',
+        education || '(none)'
+      ].join('\n')
+      const learnedContext = [
+        'BOUNDED LEARNED HOME MEMORY:',
+        habitLines.length ? habitLines.join('\n') : '(no stable habits learned yet)',
+        observationLines.length ? `\nRecent significant observations:\n${observationLines.join('\n')}` : ''
+      ].join('\n')
+      const targetChars = Math.max(500, Number(maxChars) || 6000)
+      const remainingChars = Math.max(0, targetChars - educationContext.length - 2)
+      return [
+        educationContext,
+        remainingChars > 0 ? truncatePromptText(learnedContext, remainingChars) : ''
+      ].filter(Boolean).join('\n\n')
+    }
+
     const pruneHistoryArchiveFiles = ({ force = false } = {}) => {
       if (node.historyStoreToDisk !== true) return
       const retentionDays = Math.max(1, Math.round(Number.isFinite(Number(node.historyStoreRetentionDays)) ? Number(node.historyStoreRetentionDays) : 1))
@@ -7603,47 +8533,15 @@ module.exports = function (RED) {
         })
         : baseBody
 
-      // Some OpenAI models (and some compatible gateways) require `max_completion_tokens` instead of `max_tokens`.
-      // Try with `max_tokens` first for broad compatibility, then fallback once if the server rejects it.
-      const bodyWithMaxTokens = Object.assign({ max_tokens: resolvedMaxTokens }, schemaBody)
-      const bodyWithMaxCompletionTokens = Object.assign({ max_completion_tokens: resolvedMaxTokens }, schemaBody)
-      const plainBodyWithMaxTokens = Object.assign({ max_tokens: resolvedMaxTokens }, baseBody)
-      const plainBodyWithMaxCompletionTokens = Object.assign({ max_completion_tokens: resolvedMaxTokens }, baseBody)
-
-      const isResponseFormatCompatibilityError = (message) => {
-        const msg = String(message || '')
-        return msg.includes("Unsupported parameter: 'response_format'") ||
-          msg.includes('Invalid schema for response_format') ||
-          msg.includes('response_format') ||
-          msg.includes('json_schema')
-      }
-
-      let json
-      try {
-        json = await postJson({ url, headers, body: bodyWithMaxTokens, timeoutMs: effectiveTimeoutMs })
-      } catch (error) {
-        const msg = (error && error.message) ? String(error.message) : ''
-        if (isResponseFormatCompatibilityError(msg)) {
-          try {
-            json = await postJson({ url, headers, body: plainBodyWithMaxTokens, timeoutMs: effectiveTimeoutMs })
-          } catch (innerError) {
-            const innerMsg = (innerError && innerError.message) ? String(innerError.message) : ''
-            if (innerMsg.includes("Unsupported parameter: 'max_tokens'") || innerMsg.includes('max_completion_tokens')) {
-              json = await postJson({ url, headers, body: plainBodyWithMaxCompletionTokens, timeoutMs: effectiveTimeoutMs })
-            } else if (innerMsg.includes("Unsupported parameter: 'max_completion_tokens'")) {
-              json = await postJson({ url, headers, body: plainBodyWithMaxTokens, timeoutMs: effectiveTimeoutMs })
-            } else {
-              throw innerError
-            }
-          }
-        } else if (msg.includes("Unsupported parameter: 'max_tokens'") || msg.includes('max_completion_tokens')) {
-          json = await postJson({ url, headers, body: bodyWithMaxCompletionTokens, timeoutMs: effectiveTimeoutMs })
-        } else if (msg.includes("Unsupported parameter: 'max_completion_tokens'")) {
-          json = await postJson({ url, headers, body: bodyWithMaxTokens, timeoutMs: effectiveTimeoutMs })
-        } else {
-          throw error
-        }
-      }
+      // OpenAI-compatible providers differ on optional sampling, response-format,
+      // and token-limit parameters. Retry only the rejected compatibility field.
+      const json = await postOpenAiCompatibleChatWithFallbacks({
+        url,
+        headers,
+        body: Object.assign({ max_tokens: resolvedMaxTokens }, schemaBody),
+        timeoutMs: effectiveTimeoutMs,
+        model: baseBody.model
+      })
       const content = extractOpenAICompatText(json) || buildOpenAICompatFallbackText(json)
       const finishReason = String(json && json.choices && json.choices[0] && json.choices[0].finish_reason ? json.choices[0].finish_reason : '')
       return { provider: 'openai_compat', model: baseBody.model, content, finishReason }
@@ -7844,6 +8742,309 @@ module.exports = function (RED) {
       return Object.assign({}, ret, { content: finalContent, summary })
     }
 
+    const getConversationHistory = (sessionId) => {
+      const key = String(sessionId || 'default')
+      const history = node._conversationSessions.get(key)
+      return Array.isArray(history) ? history.slice(-8) : []
+    }
+
+    const rememberConversationTurn = ({ sessionId, question, reply }) => {
+      const key = String(sessionId || 'default')
+      const history = getConversationHistory(key)
+      history.push({
+        question: String(question || '').trim(),
+        reply: String(reply || '').trim()
+      })
+      node._conversationSessions.delete(key)
+      node._conversationSessions.set(key, history.slice(-8))
+      while (node._conversationSessions.size > 50) {
+        const oldestKey = node._conversationSessions.keys().next().value
+        node._conversationSessions.delete(oldestKey)
+      }
+    }
+
+    const callConversationalLLM = async ({ question, sessionId, requireConfirmation = true }) => {
+      const summary = rebuildCachedSummaryNow()
+      const catalog = getGaCatalogSnapshot()
+      const history = getConversationHistory(sessionId)
+      const gaLimit = 600
+      const gaLines = catalog.slice(0, gaLimit).map((item) => {
+        const role = String(item && item.role ? item.role : 'neutral').trim()
+        const dpt = String(item && item.dpt ? item.dpt : '').trim() || '?'
+        const label = String(item && item.label ? item.label : item && item.ga ? item.ga : '').trim()
+        const semantic = item && item.semantic && typeof item.semantic === 'object' ? item.semantic : {}
+        const valueOptions = (Array.isArray(item && item.valueOptions) ? item.valueOptions : [])
+          .slice(0, 20)
+          .map(option => `${option.value}=${option.label}`)
+          .join(', ')
+        const semanticText = semantic.kind && semantic.kind !== 'unknown'
+          ? ` | semantic ${semantic.kind}${semantic.area ? `/${semantic.area}` : ''} confidence=${Number(semantic.confidence || 0).toFixed(2)}`
+          : ''
+        return `${item.ga} | dpt ${dpt} | role ${role} | ${label}${semanticText}${valueOptions ? ` | values ${valueOptions}` : ''}`
+      })
+      const conversationLines = history.flatMap(turn => [
+        `User: ${turn.question}`,
+        `Assistant: ${turn.reply}`
+      ])
+      const analysisContext = buildLLMPrompt({ question, summary, compact: true })
+      const systemPrompt = [
+        node.llmSystemPrompt || 'You are a KNX building automation assistant.',
+        '',
+        'KNX CHAT AND CONTROL CONTRACT:',
+        '- Return only one JSON object with exactly this shape: {"reply":"text for the user","language":"it","commands":[{"event":"GroupValue_Read|GroupValue_Write","destination":"1/2/3","dpt":"1.001","payload":null,"reason":"short reason"}]}.',
+        '- Use the same language as the user for reply and reason.',
+        '- Set language to the ISO code matching the current user request: en, it, de, fr, es, or zh.',
+        '- For an explicit request to refresh, read, query, or retrieve a current KNX state, create GroupValue_Read operations for the exact relevant objects. Use payload null for reads.',
+        '- GroupValue_Read is allowed for exact status, neutral, or command objects in AVAILABLE KNX OBJECTS because it does not modify the bus state.',
+        '- For a question that can be answered from recent data, return commands as an empty array. If current data is missing or the user explicitly asks for a fresh read, request it instead of claiming that read-only objects cannot be queried.',
+        '- Create a GroupValue_Write only when the user clearly asks to control an actuator now.',
+        '- Never invent, guess, transform, or substitute a group address or DPT.',
+        '- A GroupValue_Write destination must appear in AVAILABLE KNX OBJECTS with role command. Status and neutral objects must never receive GroupValue_Write.',
+        '- Copy the DPT exactly from AVAILABLE KNX OBJECTS.',
+        '- For every DPT 1.xxx GroupValue_Write, use a JSON boolean payload: true to activate and false to deactivate. Do not use numeric 1/0 or quoted boolean strings.',
+        '- Emit the smallest necessary operation set, in execution order, with at most 5 writes and 20 reads.',
+        '- Do not claim that an action succeeded. Say that the command is being forwarded or prepared; real KNX feedback is separate.',
+        requireConfirmation ? '- When GroupValue_Write operations are present, explain the proposed changes only. The node appends the exact localized confirmation instructions; do not invent different confirmation wording. Writes have not been sent yet. GroupValue_Read operations do not require confirmation.' : '',
+        '- If the request is ambiguous, unsafe, unsupported, or has no exact KNX object, ask a concise clarification and return no commands.'
+      ].filter(Boolean).join('\n')
+      const userContent = [
+        history.length ? 'RECENT CONVERSATION:' : '',
+        history.length ? conversationLines.join('\n') : '',
+        history.length ? '' : '',
+        getHomeMemoryPromptContext({ maxChars: 6000 }),
+        '',
+        analysisContext,
+        '',
+        `AVAILABLE KNX OBJECTS (showing ${Math.min(catalog.length, gaLimit)} of ${catalog.length}; every exact object may be read, but only role command may be written):`,
+        gaLines.length ? gaLines.join('\n') : '(no ETS group addresses imported; return no commands)',
+        '',
+        'Return the JSON object now.'
+      ].join('\n')
+      const configuredMaxTokens = Math.max(10000, Number(node.llmMaxTokens) || 0)
+      const ret = await callLLMChat({
+        systemPrompt,
+        userContent,
+        jsonSchema: {
+          name: 'knx_ai_conversation',
+          strict: true,
+          schema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+              reply: { type: 'string' },
+              language: { type: 'string', enum: ['en', 'it', 'de', 'fr', 'es', 'zh'] },
+              commands: {
+                type: 'array',
+                maxItems: 25,
+                items: {
+                  type: 'object',
+                  additionalProperties: false,
+                  properties: {
+                    event: { type: 'string', enum: ['GroupValue_Read', 'GroupValue_Write'] },
+                    destination: { type: 'string' },
+                    dpt: { type: 'string' },
+                    payload: {},
+                    reason: { type: 'string' }
+                  },
+                  required: ['event', 'destination', 'dpt', 'payload', 'reason']
+                }
+              }
+            },
+            required: ['reply', 'language', 'commands']
+          }
+        },
+        maxTokensOverride: configuredMaxTokens
+      })
+
+      let envelope
+      try {
+        envelope = parseKnxAiConversationResponse(ret.content)
+      } catch (error) {
+        return Object.assign({}, ret, {
+          content: String(ret.content || '').trim() || 'The AI provider returned an empty response.',
+          commands: [],
+          rejectedCommands: [],
+          summary,
+          structuredOutputError: error.message || String(error)
+        })
+      }
+
+      const normalized = normalizeKnxAiCommandCandidates({
+        commands: envelope.commands,
+        catalog,
+        maxCommands: 5,
+        maxReadCommands: 20,
+        coercePayload: (value, context) => coerceKnxAiCommandPayload(value, context)
+      })
+      let reply = envelope.reply || (normalized.accepted.length ? 'KNX command prepared.' : 'No response text was returned.')
+      if (normalized.rejected.length) {
+        const details = normalized.rejected.map(item => item.reason).join('; ')
+        reply += `\n\nKNX command not sent: ${details}.`
+      }
+      return Object.assign({}, ret, {
+        content: reply,
+        language: envelope.language,
+        commands: normalized.accepted,
+        rejectedCommands: normalized.rejected,
+        summary
+      })
+    }
+
+    const cloneInputMessage = inputMessage => cloneKnxAiInputMessage(
+      inputMessage,
+      RED.util && typeof RED.util.cloneMessage === 'function'
+        ? message => RED.util.cloneMessage(message)
+        : null,
+      error => {
+        try { node.sysLogger?.warn(`knxUltimateAI input message clone warning: ${error.message || error}`) } catch (e) { /* ignore */ }
+      }
+    )
+
+    const adaptAssistantOutput = (value, inputMessage) => {
+      if (!node._chatOutputAdapter || value === null || value === undefined) return value
+      const adaptOne = message => executeKnxAiChatAdapter({
+        adapter: node._chatOutputAdapter,
+        msg: message,
+        inputMessage,
+        node,
+        RED
+      })
+      try {
+        if (Array.isArray(value)) {
+          const adapted = value.map(adaptOne).filter(message => message !== null)
+          return adapted.length ? adapted : null
+        }
+        return adaptOne(value)
+      } catch (error) {
+        try { node.sysLogger?.error(`knxUltimateAI chat output adapter error: ${error.message || error}`) } catch (e) { /* ignore */ }
+        try { node.error(error, inputMessage) } catch (e) { /* ignore */ }
+        try { updateStatus({ fill: 'red', shape: 'dot', text: `Chat output adapter error: ${error.message || error}` }) } catch (e) { /* ignore */ }
+        return null
+      }
+    }
+
+    const sendKnxAiOutputs = (outputs, inputMessage) => {
+      const preparedOutputs = Array.isArray(outputs) ? outputs.slice() : outputs
+      if (Array.isArray(preparedOutputs) && preparedOutputs.length > 2) {
+        preparedOutputs[2] = adaptAssistantOutput(preparedOutputs[2], inputMessage)
+      }
+      return safeKnxAiSend({
+        outputs: preparedOutputs,
+        send: messages => node.send(messages),
+        onError: error => {
+          try { node.sysLogger?.error(`knxUltimateAI output error: ${error.message || error}`) } catch (e) { /* ignore */ }
+          try { node.error(error, inputMessage) } catch (e) { /* ignore */ }
+          try { updateStatus({ fill: 'red', shape: 'dot', text: `AI output error: ${error.message || error}` }) } catch (e) { /* ignore */ }
+        }
+      })
+    }
+
+    const buildKnxAiReplyMessage = ({ inputMessage, content, metadata = {}, summary }) => {
+      const replyMessage = cloneInputMessage(inputMessage)
+      replyMessage.topic = node.outputtopic
+      replyMessage.payload = content
+      replyMessage.knxAi = metadata
+      replyMessage.inputMessage = cloneInputMessage(inputMessage)
+      if (summary !== undefined) replyMessage.summary = summary
+      return replyMessage
+    }
+
+    const buildKnxAiCommandMessages = ({ commands, question, sessionId, confirmed, inputMessage }) => {
+      return (Array.isArray(commands) ? commands : []).map((command, index) => buildKnxAiUniversalMessage({
+        command,
+        question,
+        sessionId,
+        confirmed,
+        index,
+        inputMessage: cloneInputMessage(inputMessage)
+      }))
+    }
+
+    const handleKnxAiConfirmationDecision = ({ msg, question, sessionId, decision }) => {
+      const pending = node._pendingKnxCommands.get(sessionId)
+      const language = pending && pending.language
+        ? pending.language
+        : resolveKnxAiLanguage(msg, node.llmDocsLanguage || 'en', question)
+      const copy = getKnxAiConfirmationCopy(language)
+      if (!pending) {
+        const reply = buildKnxAiReplyMessage({
+          inputMessage: msg,
+          content: copy.missing,
+          metadata: { type: 'knx_confirmation_missing', sessionId }
+        })
+        sendKnxAiOutputs([null, null, reply, null], msg)
+        return
+      }
+      node._pendingKnxCommands.delete(sessionId)
+      if (Number(pending.expiresAt || 0) <= nowMs()) {
+        const reply = buildKnxAiReplyMessage({
+          inputMessage: msg,
+          content: copy.expired,
+          metadata: { type: 'knx_confirmation_expired', sessionId }
+        })
+        if (!sendKnxAiOutputs([null, null, reply, null], msg)) return
+        updateStatus({ fill: 'grey', shape: 'dot', text: 'AI KNX confirmation expired' })
+        return
+      }
+      if (decision === 'cancel') {
+        const reply = buildKnxAiReplyMessage({
+          inputMessage: msg,
+          content: copy.cancelled,
+          metadata: { type: 'knx_confirmation_cancelled', sessionId }
+        })
+        rememberConversationTurn({ sessionId, question: question || 'CANCEL', reply: copy.cancelled })
+        if (!sendKnxAiOutputs([null, null, reply, null], msg)) return
+        updateStatus({ fill: 'grey', shape: 'dot', text: 'AI KNX commands cancelled' })
+        return
+      }
+
+      const normalized = normalizeKnxAiCommandCandidates({
+        commands: pending.commands,
+        catalog: getGaCatalogSnapshot(),
+        maxCommands: 5,
+        coercePayload: (value, context) => coerceKnxAiCommandPayload(value, context)
+      })
+      if (normalized.rejected.length || !normalized.accepted.length) {
+        const details = normalized.rejected.length
+          ? normalized.rejected.map(item => item.reason).join('; ')
+          : 'no valid command remains'
+        const content = copy.invalid(details)
+        const reply = buildKnxAiReplyMessage({
+          inputMessage: msg,
+          content,
+          metadata: {
+            type: 'knx_confirmation_invalid',
+            sessionId,
+            rejectedCommands: normalized.rejected
+          }
+        })
+        rememberConversationTurn({ sessionId, question: question || 'CONFIRM', reply: content })
+        if (!sendKnxAiOutputs([null, null, reply, null], msg)) return
+        updateStatus({ fill: 'red', shape: 'dot', text: 'AI KNX confirmation validation failed' })
+        return
+      }
+      const commandMessages = buildKnxAiCommandMessages({
+        commands: normalized.accepted,
+        question: pending.question,
+        sessionId,
+        confirmed: true,
+        inputMessage: msg
+      })
+      const content = copy.confirmed(commandMessages.length)
+      const reply = buildKnxAiReplyMessage({
+        inputMessage: msg,
+        content,
+        metadata: {
+          type: 'knx_confirmation_accepted',
+          sessionId,
+          commandCount: commandMessages.length
+        }
+      })
+      rememberConversationTurn({ sessionId, question: question || 'CONFIRM', reply: content })
+      if (!sendKnxAiOutputs([null, null, reply, commandMessages], msg)) return
+      updateStatus({ fill: 'green', shape: 'dot', text: `AI confirmed, ${commandMessages.length} KNX command(s)` })
+    }
+
     const emitSummary = () => {
       try {
         const summary = rebuildCachedSummaryNow()
@@ -8120,6 +9321,267 @@ module.exports = function (RED) {
       node._gaState.set(ga, state)
     }
 
+    const rememberHomeOwner = ({ sessionId, language } = {}) => {
+      try {
+        const normalizedSessionId = String(sessionId || '').trim()
+        if (normalizedSessionId && normalizedSessionId !== 'default') {
+          node._homeMemory.ownerSessionId = normalizedSessionId
+        }
+        if (language) node._homeMemory.ownerLanguage = normalizeHomeLanguage(language)
+        scheduleHomeMemoryPersist()
+      } catch (error) {
+        try { node.sysLogger?.warn(`KNX AI home owner memory error: ${error.message || error}`) } catch (logError) { /* ignore */ }
+      }
+    }
+
+    const recordProactiveObservation = ({ catalogItem, telegram, event }) => {
+      const semantic = catalogItem && catalogItem.semantic ? catalogItem.semantic : {}
+      node._homeMemory = addBoundedKnxAiObservation(node._homeMemory, {
+        at: new Date(Number(telegram.ts || nowMs())).toISOString(),
+        type: 'semantic_state_change',
+        event,
+        ga: catalogItem.ga,
+        dpt: catalogItem.dpt,
+        label: catalogItem.label || telegram.devicename || catalogItem.ga,
+        kind: semantic.kind || '',
+        area: semantic.area || '',
+        value: normalizeValueForCompare(telegram.payload)
+      })
+      scheduleHomeMemoryPersist()
+    }
+
+    const processProactiveTelegram = (telegram) => {
+      if (!telegram || !telegram.destination) return
+      const catalogItem = getHomeCatalogMap().get(String(telegram.destination).trim())
+      if (!catalogItem || !catalogItem.semantic) return
+      const openState = classifyKnxAiOpenState({
+        semantic: catalogItem.semantic,
+        dpt: telegram.dpt || catalogItem.dpt,
+        payload: telegram.payload,
+        valueOptions: catalogItem.valueOptions
+      })
+      if (!openState || Number(openState.confidence || 0) < 0.7) return
+      const ga = String(catalogItem.ga || telegram.destination).trim()
+      const now = Number(telegram.ts || nowMs())
+      const previous = node._proactiveStates.get(ga)
+      if (openState.open) {
+        if (previous && previous.open === true) {
+          previous.lastSeenAt = now
+          previous.value = openState.value
+          node._proactiveStates.set(ga, previous)
+          return
+        }
+        const lastNotification = normalizeKnxAiHomeMemory(node._homeMemory).notifications
+          .filter(item => item && item.ga === ga)
+          .sort((a, b) => String(a.at || '').localeCompare(String(b.at || '')))
+          .pop()
+        node._proactiveStates.set(ga, {
+          ga,
+          open: true,
+          openedAt: now,
+          lastSeenAt: now,
+          lastSentAt: lastNotification ? Date.parse(lastNotification.at || '') || 0 : 0,
+          value: openState.value,
+          confidence: openState.confidence,
+          catalogItem
+        })
+        recordProactiveObservation({
+          catalogItem,
+          telegram,
+          event: openState.reason || 'opened'
+        })
+        return
+      }
+      if (previous && previous.open === true) {
+        const durationMinutes = Math.max(0, (now - Number(previous.openedAt || now)) / 60000)
+        node._homeMemory = updateKnxAiCoverHabit(node._homeMemory, {
+          ga,
+          label: catalogItem.label || ga,
+          area: catalogItem.semantic.area || '',
+          durationMinutes,
+          at: new Date(now).toISOString()
+        })
+        recordProactiveObservation({
+          catalogItem,
+          telegram,
+          event: `${openState.reason || 'closed'} after ${durationMinutes.toFixed(1)} minutes`
+        })
+      }
+      node._proactiveStates.set(ga, {
+        ga,
+        open: false,
+        openedAt: 0,
+        lastSeenAt: now,
+        lastSentAt: previous ? Number(previous.lastSentAt || 0) : 0,
+        value: openState.value,
+        confidence: openState.confidence,
+        catalogItem
+      })
+    }
+
+    const createProactiveNotificationText = async ({ state, durationMinutes, language }) => {
+      const label = state.catalogItem.label || state.ga
+      const fallback = buildKnxAiProactiveFallback({ language, label, durationMinutes })
+      const hasAuthoritativeEducation = String(node.aiEducation || '').trim() !== ''
+      if (node.llmEnabled !== true) {
+        return hasAuthoritativeEducation
+          ? { notify: false, content: '' }
+          : { notify: true, content: fallback }
+      }
+      try {
+        const ret = await callLLMChat({
+          systemPrompt: [
+            'You decide whether to send one concise proactive smart-home notification.',
+            `Use language ${normalizeHomeLanguage(language)}.`,
+            'Return JSON only with exactly: {"notify":boolean,"message":"text"}.',
+            'Set notify=false when the authoritative user-managed AI Education says this condition is normal, allowed, unwanted, or should not generate a notification.',
+            'When notify=false, set message to an empty string.',
+            'Do not claim that a KNX command was sent or that an actuator changed.',
+            'The message must not contain Markdown, lists, addresses, DPTs, or technical details.',
+            'Explain the observed condition and end by asking whether the user wants help.',
+            'The user-managed AI Education is authoritative.'
+          ].join('\n'),
+          userContent: [
+            getHomeMemoryPromptContext({ maxChars: 3500 }),
+            '',
+            `Observed object: ${label}`,
+            `Semantic type: ${state.catalogItem.semantic.kind}`,
+            `Semantic area: ${state.catalogItem.semantic.area || 'unknown'}`,
+            `Condition duration: ${Math.max(1, Math.round(durationMinutes))} minutes`,
+            'Return the JSON decision now.'
+          ].join('\n'),
+          jsonSchema: {
+            name: 'knx_ai_proactive_decision',
+            strict: true,
+            schema: {
+              type: 'object',
+              additionalProperties: false,
+              properties: {
+                notify: { type: 'boolean' },
+                message: { type: 'string' }
+              },
+              required: ['notify', 'message']
+            }
+          },
+          maxTokensOverride: 2000
+        })
+        const decision = extractJsonFragmentFromText(ret && ret.content)
+        if (!decision || typeof decision !== 'object' || Array.isArray(decision) || typeof decision.notify !== 'boolean') {
+          throw new Error('The proactive decision is not a valid JSON object')
+        }
+        if (decision.notify === false) return { notify: false, content: '' }
+        const candidate = String(decision.message || '').trim()
+        if (!candidate || candidate.length > 1200 || candidate.startsWith('{') || candidate.startsWith('```')) {
+          return { notify: true, content: fallback }
+        }
+        return { notify: true, content: candidate }
+      } catch (error) {
+        try { node.sysLogger?.warn(`KNX AI proactive wording fallback: ${error.message || error}`) } catch (logError) { /* ignore */ }
+        return hasAuthoritativeEducation
+          ? { notify: false, content: '' }
+          : { notify: true, content: fallback }
+      }
+    }
+
+    const emitProactiveNotification = async ({ state, durationMinutes }) => {
+      if (node._closing === true) return false
+      const recipient = String(node.proactiveRecipient || node._homeMemory.ownerSessionId || '').trim()
+      if (node.chatAdapterPreset === 'windkh-telegrambot' && !recipient) return false
+      const language = normalizeHomeLanguage(node._homeMemory.ownerLanguage || node.llmDocsLanguage || 'en')
+      const notification = await createProactiveNotificationText({ state, durationMinutes, language })
+      if (!notification.notify) return 'suppressed'
+      const content = notification.content
+      if (node._closing === true) return false
+      const syntheticInputMessage = {
+        topic: 'proactive',
+        payload: Object.assign({
+          type: 'message',
+          content: ''
+        }, recipient ? { chatId: recipient } : {}),
+        sessionId: recipient || 'proactive',
+        language,
+        knxAi: {
+          type: 'proactive_observation',
+          destination: state.ga
+        }
+      }
+      const metadata = {
+        type: 'proactive_notification',
+        reason: 'open_too_long',
+        destination: state.ga,
+        dpt: state.catalogItem.dpt,
+        label: state.catalogItem.label || state.ga,
+        semantic: state.catalogItem.semantic,
+        openedAt: new Date(state.openedAt).toISOString(),
+        durationMinutes: Number(durationMinutes.toFixed(1)),
+        recipient,
+        sessionId: recipient || 'proactive',
+        language,
+        requiresConfirmationForCommands: true
+      }
+      const replyMessage = buildKnxAiReplyMessage({
+        inputMessage: syntheticInputMessage,
+        content,
+        metadata
+      })
+      if (!sendKnxAiOutputs([null, null, replyMessage, null], syntheticInputMessage)) return false
+      node._homeMemory = addBoundedKnxAiNotification(node._homeMemory, {
+        at: new Date().toISOString(),
+        type: 'proactive_notification',
+        reason: 'open_too_long',
+        ga: state.ga,
+        dpt: state.catalogItem.dpt,
+        label: state.catalogItem.label || state.ga,
+        durationMinutes: Number(durationMinutes.toFixed(1)),
+        recipient
+      })
+      rememberConversationTurn({
+        sessionId: recipient || 'proactive',
+        question: '[Proactive home observation]',
+        reply: content
+      })
+      scheduleHomeMemoryPersist({ immediate: true })
+      return true
+    }
+
+    const checkProactiveHomeState = () => {
+      if (node._closing === true || node.proactiveEnabled !== true) return
+      if (isKnxAiQuietTime({
+        date: new Date(),
+        start: node.proactiveQuietStart,
+        end: node.proactiveQuietEnd
+      })) return
+      const now = nowMs()
+      const thresholdMs = node.proactiveOpenMinutes * 60 * 1000
+      const cooldownMs = node.proactiveCooldownMinutes * 60 * 1000
+      node._proactiveGlobalSentAt = node._proactiveGlobalSentAt.filter(ts => (now - ts) < (60 * 60 * 1000))
+      if (node._proactiveGlobalSentAt.length >= 3) return
+      const candidate = Array.from(node._proactiveStates.values())
+        .filter(state => {
+          if (!state || state.open !== true || node._proactiveInFlight.has(state.ga)) return false
+          if ((now - Number(state.openedAt || now)) < thresholdMs) return false
+          if (Number(state.lastSentAt || 0) > 0 && (now - Number(state.lastSentAt)) < cooldownMs) return false
+          return true
+        })
+        .sort((a, b) => Number(a.openedAt || 0) - Number(b.openedAt || 0))[0]
+      if (!candidate) return
+      candidate.lastSentAt = now
+      node._proactiveInFlight.add(candidate.ga)
+      const durationMinutes = Math.max(1, (now - Number(candidate.openedAt || now)) / 60000)
+      Promise.resolve(emitProactiveNotification({ state: candidate, durationMinutes }))
+        .then(result => {
+          if (result === true) node._proactiveGlobalSentAt.push(now)
+          else if (result !== 'suppressed') candidate.lastSentAt = 0
+        })
+        .catch(error => {
+          candidate.lastSentAt = 0
+          try { node.sysLogger?.warn(`KNX AI proactive notification error: ${error.message || error}`) } catch (logError) { /* ignore */ }
+        })
+        .finally(() => {
+          node._proactiveInFlight.delete(candidate.ga)
+        })
+    }
+
     // Called by knxUltimate-config.js
     node.handleSend = (msg) => {
       try {
@@ -8133,6 +9595,7 @@ module.exports = function (RED) {
         trimHistory(now)
         maybeEmitGAAnomalies(telegram)
         maybeEmitOverallAnomaly(now)
+        processProactiveTelegram(telegram)
         scheduleRealtimeSummaryRebuild()
       } catch (error) {
         try { node.sysLogger?.error(`knxUltimateAI handleSend error: ${error.message || error}`) } catch (e) { /* ignore */ }
@@ -8156,6 +9619,13 @@ module.exports = function (RED) {
           }]
           node._lastSummary = null
           node._lastSummaryAt = 0
+          node._conversationSessions = new Map()
+          node._pendingKnxCommands = new Map()
+          node._homeMemory = createEmptyKnxAiHomeMemory()
+          node._proactiveStates = new Map()
+          node._proactiveInFlight = new Set()
+          node._proactiveGlobalSentAt = []
+          scheduleHomeMemoryPersist({ immediate: true })
           if (node._summaryRebuildTimer) {
             clearTimeout(node._summaryRebuildTimer)
             node._summaryRebuildTimer = null
@@ -8165,40 +9635,205 @@ module.exports = function (RED) {
           return
         }
 
+        if (cmd === 'confirm' || cmd === 'cancel') {
+          const question = extractKnxAiQuestion(msg)
+          const sessionId = resolveKnxAiSessionId(msg)
+          handleKnxAiConfirmationDecision({
+            msg,
+            question,
+            sessionId,
+            decision: cmd === 'confirm' ? 'confirm' : 'cancel'
+          })
+          return
+        }
+
         if (cmd === 'summary' || cmd === 'stats' || cmd === 'top' || cmd === '') {
           emitSummary()
           return
         }
 
         if (cmd === 'ask') {
-          const question = (msg.prompt !== undefined)
-            ? String(msg.prompt)
-            : (typeof msg.payload === 'string' ? msg.payload : safeStringify(msg.payload))
+          const question = extractKnxAiQuestion(msg)
+          const sessionId = resolveKnxAiSessionId(msg)
+          if (!question) throw new Error('Missing question')
+          const decision = classifyKnxAiConfirmation({ msg, question, topic: cmd })
+          if (node._pendingKnxCommands.has(sessionId) && decision !== 'none') {
+            handleKnxAiConfirmationDecision({ msg, question, sessionId, decision })
+            return
+          }
+          // A new natural-language request replaces an older unconfirmed plan in
+          // the same chat, preventing a later confirmation from acting on stale intent.
+          node._pendingKnxCommands.delete(sessionId)
           updateStatus({ fill: 'blue', shape: 'ring', text: 'AI thinking...' })
           try {
-            const ret = await callLLM({ question })
-            node._assistantLog.push({ at: new Date().toISOString(), question, content: ret.content, provider: ret.provider, model: ret.model })
+            const ret = node.llmAllowKnxCommands
+              ? await callConversationalLLM({
+                question,
+                sessionId,
+                requireConfirmation: node.llmRequireCommandConfirmation
+              })
+              : await callLLM({ question })
+            const preparedCommands = Array.isArray(ret.commands) ? ret.commands : []
+            const readCommands = preparedCommands.filter(command => command && command.event === 'GroupValue_Read')
+            const writeCommands = preparedCommands.filter(command => !command || command.event !== 'GroupValue_Read')
+            const language = resolveKnxAiLanguage(msg, node.llmDocsLanguage || 'en', question, ret.language)
+            rememberHomeOwner({ sessionId, language })
+            const copy = getKnxAiConfirmationCopy(language)
+            const awaitingConfirmation = node.llmAllowKnxCommands &&
+              node.llmRequireCommandConfirmation &&
+              writeCommands.length > 0
+            let content = ret.content
+            let commandsToEmit = preparedCommands
+            let confirmationRequest = null
+            if (awaitingConfirmation) {
+              content = `${content}\n\n${formatKnxAiCommandPreview({ commands: writeCommands, copy })}`
+              const expiresAt = nowMs() + (5 * 60 * 1000)
+              node._pendingKnxCommands.set(sessionId, {
+                question,
+                commands: writeCommands,
+                language,
+                createdAt: nowMs(),
+                expiresAt
+              })
+              confirmationRequest = buildKnxAiConfirmationRequest({
+                sessionId,
+                expiresAt,
+                commandCount: writeCommands.length,
+                copy
+              })
+              while (node._pendingKnxCommands.size > 50) {
+                const oldestSessionId = node._pendingKnxCommands.keys().next().value
+                node._pendingKnxCommands.delete(oldestSessionId)
+              }
+              commandsToEmit = readCommands
+            }
+            const commandMessages = buildKnxAiCommandMessages({
+              commands: commandsToEmit,
+              question,
+              sessionId,
+              confirmed: node.llmRequireCommandConfirmation !== true,
+              inputMessage: msg
+            })
+            const emittedReadCommands = commandsToEmit.filter(command => command && command.event === 'GroupValue_Read')
+            let readResults = []
+            let readResultMetadata = []
+            if (emittedReadCommands.length > 0) {
+              const readStartedAt = nowMs()
+              const readWaiters = emittedReadCommands.map(command => waitForTelegram({
+                destination: command.destination,
+                events: ['GroupValue_Response', 'GroupValue_Write'],
+                minTs: readStartedAt,
+                timeoutMs: 6000
+              }))
+              if (!sendKnxAiOutputs([null, null, null, commandMessages], msg)) return
+              updateStatus({
+                fill: 'blue',
+                shape: 'ring',
+                text: `AI waiting for ${emittedReadCommands.length} KNX read response(s)`
+              })
+              readResults = await Promise.allSettled(readWaiters)
+              readResultMetadata = emittedReadCommands.map((command, index) => {
+                const result = readResults[index]
+                const telegram = result && result.status === 'fulfilled' ? result.value : null
+                return {
+                  destination: command.destination,
+                  dpt: command.dpt,
+                  label: command.label || '',
+                  received: !!telegram,
+                  event: telegram ? telegram.event : '',
+                  payload: telegram ? telegram.payload : undefined,
+                  payloadmeasureunit: telegram ? telegram.payloadmeasureunit : ''
+                }
+              })
+              const readReply = formatKnxAiReadResults({
+                operations: emittedReadCommands,
+                results: readResults,
+                language
+              })
+              content = writeCommands.length > 0 ? `${readReply}\n\n${content}` : readReply
+            }
+            const assistantEntry = {
+              at: new Date().toISOString(),
+              question,
+              content,
+              provider: ret.provider,
+              model: ret.model,
+              sessionId,
+              commandCount: writeCommands.length,
+              readCount: readCommands.length,
+              language,
+              awaitingConfirmation,
+              rejectedCommandCount: Array.isArray(ret.rejectedCommands) ? ret.rejectedCommands.length : 0
+            }
+            node._assistantLog.push(assistantEntry)
             while (node._assistantLog.length > 50) node._assistantLog.shift()
-            node.send([null, null, {
-              topic: node.outputtopic,
-              payload: ret.content,
-              knxAi: { type: 'llm', provider: ret.provider, model: ret.model, question },
-              summary: ret.summary
-            }])
-            updateStatus({ fill: 'green', shape: 'dot', text: 'AI answer ready' })
+            if (node.llmAllowKnxCommands) rememberConversationTurn({ sessionId, question, reply: content })
+            const replyMessage = buildKnxAiReplyMessage({
+              inputMessage: msg,
+              content,
+              metadata: {
+                type: 'llm',
+                provider: ret.provider,
+                model: ret.model,
+                question,
+                sessionId,
+                language,
+                operationCount: preparedCommands.length,
+                commandCount: writeCommands.length,
+                readCount: readCommands.length,
+                readResults: readResultMetadata,
+                awaitingConfirmation,
+                confirmationExpiresAt: confirmationRequest ? confirmationRequest.expiresAt : 0,
+                confirmationRequest,
+                rejectedCommands: Array.isArray(ret.rejectedCommands) ? ret.rejectedCommands : [],
+                structuredOutputError: ret.structuredOutputError || ''
+              },
+              summary: emittedReadCommands.length > 0 ? rebuildCachedSummaryNow() : ret.summary
+            })
+            if (emittedReadCommands.length > 0) {
+              if (!sendKnxAiOutputs([null, null, replyMessage, null], msg)) return
+            } else if (!sendKnxAiOutputs([null, null, replyMessage, commandMessages.length ? commandMessages : null], msg)) {
+              return
+            }
+            updateStatus({
+              fill: awaitingConfirmation ? 'yellow' : 'green',
+              shape: awaitingConfirmation ? 'ring' : 'dot',
+              text: awaitingConfirmation
+                ? `AI waiting for confirmation (${writeCommands.length} KNX command(s))`
+                : readCommands.length
+                  ? `AI answer ready, ${readResultMetadata.filter(item => item.received).length}/${readCommands.length} KNX read(s) received`
+                  : commandMessages.length
+                    ? `AI answer ready, ${commandMessages.length} KNX command(s)`
+                    : 'AI answer ready'
+            })
           } catch (error) {
             node._assistantLog.push({ at: new Date().toISOString(), question, error: error.message || String(error) })
             while (node._assistantLog.length > 50) node._assistantLog.shift()
-            node.send([null, null, {
-              topic: node.outputtopic,
-              payload: { error: error.message || String(error) },
-              knxAi: { type: 'llm_error', question }
-            }])
+            const replyMessage = buildKnxAiReplyMessage({
+              inputMessage: msg,
+              content: { error: error.message || String(error) },
+              metadata: { type: 'llm_error', question }
+            })
+            if (!sendKnxAiOutputs([null, null, replyMessage, null], msg)) return
             updateStatus({ fill: 'red', shape: 'dot', text: `AI error: ${error.message || error}` })
           }
           return
         }
 
+        if (cmd === 'clear_chat') {
+          const sessionId = resolveKnxAiSessionId(msg)
+          node._conversationSessions.delete(sessionId)
+          node._pendingKnxCommands.delete(sessionId)
+          const replyMessage = buildKnxAiReplyMessage({
+            inputMessage: msg,
+            content: { ok: true, sessionId },
+            metadata: { type: 'conversation_reset', sessionId }
+          })
+          if (!sendKnxAiOutputs([null, null, replyMessage, null], msg)) return
+          updateStatus({ fill: 'grey', shape: 'dot', text: `AI chat cleared (${sessionId})` })
+          return
+        }
+
         if (cmd === 'run_profile') {
           const areaId = msg.areaId !== undefined ? String(msg.areaId) : (msg.payload && msg.payload.areaId ? String(msg.payload.areaId) : '')
           const profileId = msg.profileId !== undefined ? String(msg.profileId) : (msg.payload && msg.payload.profileId ? String(msg.payload.profileId) : '')
@@ -8249,7 +9884,7 @@ module.exports = function (RED) {
           return
         }
 
-        node.warn(`knxUltimateAI: unknown command '${cmd}'. Supported: reset, summary, ask, run_profile, run_actuator_test, run_test_plan`)
+        node.warn(`knxUltimateAI: unknown command '${cmd}'. Supported: reset, summary, ask, confirm, cancel, clear_chat, run_profile, run_actuator_test, run_test_plan`)
       } catch (error) {
         try { node.sysLogger?.error(`knxUltimateAI handleCommand error: ${error.message || error}`) } catch (e) { /* ignore */ }
         try { node.error(error) } catch (e) { /* ignore */ }
@@ -8329,11 +9964,27 @@ module.exports = function (RED) {
 
     node.on('input', function (msg) {
       try {
-        const p = handleCommand(msg)
+        let adaptedMessage = msg
+        try {
+          adaptedMessage = executeKnxAiChatAdapter({
+            adapter: node._chatInputAdapter,
+            msg,
+            inputMessage: msg,
+            node,
+            RED
+          })
+        } catch (error) {
+          try { node.sysLogger?.error(`knxUltimateAI chat input adapter error: ${error.message || error}`) } catch (e) { /* ignore */ }
+          try { node.error(error, msg) } catch (e) { /* ignore */ }
+          try { updateStatus({ fill: 'red', shape: 'dot', text: `Chat input adapter error: ${error.message || error}` }) } catch (e) { /* ignore */ }
+          return
+        }
+        if (!adaptedMessage) return
+        const p = handleCommand(adaptedMessage)
         if (p && typeof p.catch === 'function') {
           p.catch((error) => {
             try { node.sysLogger?.error(`knxUltimateAI input error: ${error.message || error}`) } catch (e) { /* ignore */ }
-            try { node.error(error) } catch (e) { /* ignore */ }
+            try { node.error(error, adaptedMessage) } catch (e) { /* ignore */ }
           })
         }
       } catch (error) {
@@ -8344,8 +9995,16 @@ module.exports = function (RED) {
 
     node.on('close', function (done) {
       try {
+        node._closing = true
         if (node._timerEmit) clearInterval(node._timerEmit)
         if (node._busConnectionWatchTimer) clearInterval(node._busConnectionWatchTimer)
+        if (node._homeMemoryPeriodicTimer) clearInterval(node._homeMemoryPeriodicTimer)
+        if (node._proactiveCheckTimer) clearInterval(node._proactiveCheckTimer)
+        if (node._homeMemoryWriteTimer) {
+          clearTimeout(node._homeMemoryWriteTimer)
+          node._homeMemoryWriteTimer = null
+        }
+        persistHomeMemoryNow()
         if (node._summaryRebuildTimer) {
           clearTimeout(node._summaryRebuildTimer)
           node._summaryRebuildTimer = null
@@ -8381,10 +10040,23 @@ module.exports = function (RED) {
     try {
       pruneHistoryArchiveFiles({ force: true })
       loadRecentHistoryFromDisk()
+      loadHomeMemoryFromDisk()
     } catch (error) {
       node.sysLogger?.warn(`KNX AI history startup error: ${error.message || error}`)
     }
 
+    if (node._homeMemoryPeriodicTimer) clearInterval(node._homeMemoryPeriodicTimer)
+    node._homeMemoryPeriodicTimer = setInterval(() => {
+      try { persistHomeMemoryNow() } catch (error) { /* persistHomeMemoryNow already guards */ }
+    }, 15 * 60 * 1000)
+
+    if (node._proactiveCheckTimer) clearInterval(node._proactiveCheckTimer)
+    node._proactiveCheckTimer = setInterval(() => {
+      try { checkProactiveHomeState() } catch (error) {
+        try { node.sysLogger?.warn(`KNX AI proactive check error: ${error.message || error}`) } catch (logError) { /* ignore */ }
+      }
+    }, 30 * 1000)
+
     if (node._busConnectionWatchTimer) clearInterval(node._busConnectionWatchTimer)
     node._busConnectionWatchTimer = setInterval(() => {
       pollBusConnectionStatus()
@@ -8400,3 +10072,30 @@ module.exports = function (RED) {
     }
   })
 }
+
+module.exports.__test = {
+  buildKnxAiConfirmationRequest,
+  buildKnxAiUniversalMessage,
+  classifyKnxAiConfirmation,
+  cloneKnxAiInputMessage,
+  compileKnxAiChatAdapter,
+  coerceKnxAiCommandPayload,
+  detectKnxAiLanguageFromText,
+  executeKnxAiChatAdapter,
+  extractKnxAiQuestion,
+  formatKnxAiCommandPreview,
+  formatKnxAiReadResults,
+  getKnxAiConfirmationCopy,
+  getKnxAiReadCopy,
+  isChatCompletionsModelError,
+  isProbablyChatModelId,
+  isUnsupportedTemperatureError,
+  normalizeKnxAiCommandCandidates,
+  parseKnxAiConversationResponse,
+  postOpenAiCompatibleChatWithFallbacks,
+  resolveKnxAiLanguage,
+  resolveKnxAiOperationEvent,
+  resolveKnxAiSessionId,
+  safeKnxAiSend,
+  validateKnxAiPayloadForDpt
+}