node-red-contrib-knx-ultimate 6.3.19 → 6.3.22

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

@@ -31,7 +31,7 @@ Canvas 上的节点状态专门用于显示最近收到的请求，以及 LLM
 对于 DPT 1.xxx 写入，AI 生成的安全等价值 `true`/`false`、`1`/`0` 和 `on`/`off` 会在本地校验和输出前统一转换为真正的布尔值。
 
 ### 最新 KNX 读取
-当用户明确要求当前或最新状态时，AI 可以查询已导入 ETS 目录中的精确对象，包括状态对象和其他只读对象。输出 4 会发送 `msg.destination`、`msg.dpt`、`msg.event = "GroupValue_Read"` 和 `msg.readstatus = true`。节点会为每个 `GroupValue_Response` 或最新写入等待最多 6 秒，然后在输出 3 返回解码值，并在 `msg.knxAi.readResults` 中提供详细信息。读取从不需要确认，也绝不会转换为写入。
+当用户明确要求当前或最新状态时，AI 可以查询已导入 ETS 目录中的精确对象，包括状态对象和其他只读对象。输出 4 会发送 `msg.destination`、`msg.dpt`、`msg.event = "GroupValue_Read"` 和 `msg.readstatus = true`。节点会为每个 `GroupValue_Response` 或最新写入等待最多 6 秒，然后在输出 3 返回解码值，并在 `msg.knxAi.readResults` 中提供详细信息。读取从不需要确认，也绝不会转换为写入。如果小型本地模型省略操作类型和 payload，精确的 ETS 对象会被安全规范化为读取；包含 payload 的项目仍作为经过验证的写入处理。
 
 ### 多步骤对话例行程序
 “我要离家”“晚安”或“影院模式”等请求可以在不增加编辑器选项的情况下，根据当前状态协调例行程序。第一次 LLM 处理仅接受精确的 ETS 读取（最多 20 个）；KNX AI 发送读取，并把最新的 GA/DPT/值结果交给隔离的第二次规划处理。第二次处理最多可准备 12 个已验证写入，但不能再次发起读取循环。启用确认时，整个计划只需一次本地化确认；确认前不会发送任何写入或所请求的 TTS 播报。确认后，每个写入都会重新验证、按顺序转发，并在最多 4 秒内观察总线上匹配的即时反馈。最终回复会区分已观察到反馈的操作与没有即时反馈的操作，但不会把后者报告为设备故障。详细信息位于 `msg.knxAi.routine`、`readResults`、`verifiedCount` 和 `unverifiedCount`。
@@ -51,13 +51,15 @@ Canvas 上的节点状态专门用于显示最近收到的请求，以及 LLM
 
 用户可以请求当前快照，或询问视觉模型画面中可见的内容。Telegram 和 RedBot 预设会把图像作为带说明文字的原生照片发送。用户还可以为移动、智能越线或进入入侵/徘徊区域创建持久通知，并可按检测到的人员以及指定名称的线或区域进行限制。这些规则保存在同一个 `knxai-chat-context.md` 文件中，并在 Node-RED 重启后恢复。UniFi 事件订阅和快照请求直接通过检测到的提供方完成；不会使用 KNX AI 输出 4，也不需要中间 Flow 连线。
 
+自动检测到的适配器发布的每个事件都会被标准化，并追加到 `knxultimatestorage/knxai/adapter-history/<节点ID>/` 下的每日 `YYYY-MM-DD.jsonl` 文件。存档保留 10 天，保证超过 24 小时的历史，只保存事件元数据，不保存图像。Web 助手和所有 CHAT 渠道会同时查询它与每日 KNX 报文存档。总数涵盖所请求区间内的全部存档行；选出的详情仅是相关样本。
+
 ### 使用 TTS Ultimate 播报
 安装可选软件包 `node-red-contrib-tts-ultimate` 后，它会显示在自动检测的适配器中。选择器会列出项目所有 Flow 中的全部 `ttsultimate` 节点，并显示 Flow、节点名称和已配置的播放器。请选择负责聊天播报的节点，然后部署 Flow。
 
 只有当前聊天消息中的明确请求才能创建播报。KNX AI 会将准确文本作为 `msg.payload` 直接发送到所选节点，并设置 `msg.topic = "knx_ai_announcement"`；无需在 Flow 中增加中间连线。之后由 TTS Ultimate 处理已配置的 Sonos 播放器、语音、音量、提示音和队列。持久上下文、AI 教育、摄像机内容和推断事件绝不会自行触发语音。
 
 ### 聊天上下文概览
-节点编辑器会显示一张紧凑卡片，汇总聊天可用的来源：当前 KNX 流量、ETS 语义与 Node-RED 项目、会话和家庭记忆、AI 教育、检测到的摄像机及相关文档。卡片还会列出 `knxai-chat-context.md`、`knxai-home-memory.md` 和 `knxai-config-<节点-id>.json`，以及 KNX 报文归档的绝对根目录、该节点专用目录和每日文件模式 `YYYY-MM-DD.jsonl`。这些路径会在运行时根据已配置网关实际使用的数据目录解析。
+节点编辑器会显示一张紧凑卡片，汇总聊天可用的来源：当前 KNX 流量、ETS 语义与 Node-RED 项目、会话和家庭记忆、AI 教育及检测到的摄像机。卡片还会显示最大运行上下文和上次聊天提示词的实际 UTF-8 大小；提供商返回输入令牌数时使用精确值，否则明确标为估算值。卡片还会列出 `knxai-chat-context.md`、`knxai-home-memory.md` 和 `knxai-config-<节点-id>.json`，以及 KNX 报文归档的绝对根目录、该节点专用目录和每日文件模式 `YYYY-MM-DD.jsonl`。这些路径会在运行时根据已配置网关实际使用的数据目录解析。
 
 ## 由 AI 教育驱动的主动家庭智能与有限记忆
 节点会根据 ETS 层级、名称、角色和 DPT 建立确定性的语义模型。不再提供单独的开关或高级主动通知设置。只有启用 LLM 且 **AI 教育**明确要求时，系统才会评估通知。条件、持续时间、静默时段和重复频率完全由 AI 教育定义。没有明确规则或 LLM 无法评估时，不会发送任何消息。
@@ -112,7 +114,7 @@ Canvas 上的节点状态专门用于显示最近收到的请求，以及 LLM
 - **发送 KNX 命令前请求确认**：默认启用。先显示已验证的修改，在同一聊天会话确认前不会发送任何 KNX 命令。有命令等待确认时，回复始终会使用当前请求的语言附加准确的确认或取消说明。命令会在输出前再次验证。
 - **适配器预设**：默认为**无适配器**。选择后会加载预定义的输入和输出映射；两者在编辑器中始终保持隐藏。
 - **AI 教育**：仅由用户管理的权威指导，AI 可以读取但永远不能修改。主动通知及其条件、持续时间、静默时段和重复频率只能在这里定义。
-- 相关的帮助、README 和示例片段始终会自动包含；系统会从用户请求中自动识别语言，并在所有受支持语言之间自动回退。
+- 软件包附带的帮助、README、更新日志、Wiki 和示例片段不会加入 Telegram、RedBot 或自定义 CHAT 的提示词；仅网页助手在回答软件包技术问题时仍可使用这些内容。
 - **Refresh** 按钮：请求 provider 并加载可用模型 ID。加载期间图标会旋转；成功完成时不会显示额外消息。
 
 ### Ollama 快速配置（本地）
@@ -123,6 +125,7 @@ Canvas 上的节点状态专门用于显示最近收到的请求，以及 LLM
   - **2) Install it**：在本机下载并安装模型（例如 `llama3.1`）。
 - 在刷新/安装模型时，KNX AI 也会在可能情况下尝试自动启动 Ollama 服务。
 - 若安装因连接错误失败，请确认 Ollama 已运行（桌面应用或 `ollama serve`）。
+- `/api/show` 报告的最大上下文仅用于显示。KNX AI 始终发送 `num_ctx = 16384`（若模型最大值更小则使用该值），并使用同一个按相关性选择的 16K 语义视图，从而避免分配过大的 KV 缓存，同时保留代理能力。
 - 若 Node-RED 运行在 Docker 中，endpoint 请使用 `host.docker.internal` 替代 `localhost`。
 
 ### Bionic LM Studio 快速配置（本地）
@@ -130,6 +133,7 @@ Canvas 上的节点状态专门用于显示最近收到的请求，以及 LLM
 - 在 LM Studio 的 **Developer** 页面启动 API 服务，或运行 `lms server start`。
 - 默认 endpoint：`http://localhost:1234/v1/chat/completions`。
 - 点击 **Refresh** 加载 `/v1/models` 提供的全部模型；未配置模型时会自动选择第一个。
+- 如果模型已加载，KNX AI 会保留其当前上下文长度。KNX AI 不会通过管理 API 加载未运行的 Bionic 模型：首次聊天请求会让 Bionic 根据该模型已保存的默认值进行 JIT 加载。无论 Bionic 报告的上下文是多少，KNX AI 都会将自己的提示词限制为按相关性选择的 16K 语义视图；这样可避免发送完整的 131K 数据集，同时保留推理、KNX、例程、摄像头和 TTS 能力。
 - 除非在 LM Studio 服务设置中启用了身份验证，否则 API Key 可留空。在 Docker 中请将 `localhost` 替换为 `host.docker.internal`。
 
 ## 安全说明

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

@@ -55,10 +55,12 @@
     },
     "messages": {
       "lmStudioContextAvailable": "模型最大上下文",
-      "lmStudioContextLoading": "正在以最大上下文加载模型",
-      "lmStudioContextConfigured": "已配置模型最大上下文",
+      "lmStudioContextLoading": "正在检查模型的当前上下文",
+      "lmStudioContextInactive": "模型未运行；首次请求时将使用 Bionic 默认值",
+      "lmStudioContextConfigured": "模型当前上下文",
       "lmStudioContextFailed": "无法配置模型上下文",
       "lmStudioContextCurrentlyLoaded": "当前已加载",
+      "localContextBudget": "KNX AI 上下文预算",
       "ollamaNotSupported": "Ollama local mode: API key not required. Default endpoint is http://localhost:11434/api/chat.",
       "ollamaNoModels": "No local Ollama model found. Install one or pick one from the library.",
       "installingOllamaModel": "Starting Ollama and installing model…",
@@ -79,13 +81,22 @@
       "chatContextLoading": "正在加载聊天上下文摘要…",
       "chatContextUnavailable": "聊天上下文摘要暂时不可用。",
       "chatContextIntro": "聊天会自动接收这些来源。以下路径是此 Node-RED 安装实际使用的路径。",
+      "chatContextLimitLabel": "最大运行上下文",
+      "chatContextProviderManaged": "由所选提供商/模型管理",
+      "chatContextTokens": "令牌",
+      "chatContextLastPromptLabel": "上次聊天提示词的实际大小",
+      "chatContextLastPromptUnavailable": "首次聊天请求前不可用",
+      "chatContextExactInputTokens": "提供商测量的输入令牌",
+      "chatContextEstimatedInputTokens": "估算输入令牌",
+      "chatContextImages": "图像",
       "chatContextSourcesTitle": "包含的来源",
       "chatContextFilesTitle": "持久化上下文文件",
       "chatContextDirectoriesTitle": "KNX 报文归档",
       "chatContextSourceKnxTraffic": "当前 KNX 摘要、异常、拓扑和选定报文。",
+      "chatContextSourceAdapterHistory": "自动检测到的适配器事件的持久每日历史记录，包括摄像机检测事件。",
       "chatContextSourceEtsProject": "ETS 语义和完整的 Node-RED 项目清单。",
       "chatContextSourceMemoryEducation": "会话上下文、AI 教育和有界家庭记忆。",
-      "chatContextSourceCamerasDocs": "检测到的摄像机以及相关帮助、README 和示例片段。",
+      "chatContextSourceCameras": "检测到的摄像机及其可用功能。",
       "chatContextSourceTtsUltimate": "已选择用于播报的 TTS Ultimate 节点。",
       "chatContextSourceBadge": "来源",
       "chatContextFileChatContext": "持久化对话轮次、指令和摄像机通知规则。",
@@ -95,6 +106,9 @@
       "chatContextDirectoryRoot": "报文归档根目录",
       "chatContextDirectoryNode": "此节点的报文归档",
       "chatContextDirectoryBadge": "KNX",
+      "chatContextDirectoryAdapterRoot": "适配器事件存档根目录",
+      "chatContextDirectoryAdapterNode": "此节点的适配器事件存档",
+      "chatContextDirectoryAdapterBadge": "适配器",
       "chatContextTelegramPattern": "每日文件",
       "chatAdapterIntro": "选择预设即可插入输入和输出映射代码。列表从随包提供的聊天适配器文件加载；生成的代码仍可编辑。",
       "chatAdapterCodeHelp": "映射同步运行。返回 msg 以继续，或不返回值以丢弃消息。错误会被捕获并报告，不会停止 Node-RED。",

package/nodes/utils/knxAiEventHistory.js

@@ -0,0 +1,246 @@
+const KNX_AI_ADAPTER_HISTORY_MIN_HOURS = 24
+const KNX_AI_HISTORY_DETAILS_MAX_CHARS = 12000
+
+const clampText = (value, maxChars = 500) => String(value === undefined || value === null ? '' : value)
+  .trim()
+  .slice(0, Math.max(0, Number(maxChars) || 0))
+
+const normalizeSearchText = value => clampText(value, 4000)
+  .normalize('NFKD')
+  .replace(/[\u0300-\u036f]/g, '')
+  .toLocaleLowerCase()
+  .replace(/[^a-z0-9./_-]+/g, ' ')
+  .trim()
+
+const parseTimestamp = (value, fallback = Date.now()) => {
+  if (typeof value === 'number' && Number.isFinite(value)) return value > 100000000000 ? value : value * 1000
+  const parsed = new Date(String(value || '')).getTime()
+  return Number.isFinite(parsed) ? parsed : fallback
+}
+
+const sanitizeHistoryValue = (value, depth = 0, seen = new Set()) => {
+  if (value === null || value === undefined) return value
+  if (typeof value === 'string') return clampText(value, 1000)
+  if (typeof value === 'number' || typeof value === 'boolean') return value
+  if (typeof value === 'bigint') return String(value)
+  if (Buffer.isBuffer(value)) return `[binary ${value.length} bytes]`
+  if (typeof value !== 'object') return clampText(value, 1000)
+  if (depth >= 3 || seen.has(value)) return '[nested]'
+  seen.add(value)
+  if (Array.isArray(value)) {
+    const out = value.slice(0, 30).map(item => sanitizeHistoryValue(item, depth + 1, seen))
+    seen.delete(value)
+    return out
+  }
+  const out = {}
+  Object.keys(value).slice(0, 60).forEach(key => {
+    const normalizedKey = clampText(key, 120)
+    if (!normalizedKey || /^(data|image|snapshot|buffer|base64)$/i.test(normalizedKey)) return
+    out[normalizedKey] = sanitizeHistoryValue(value[key], depth + 1, seen)
+  })
+  seen.delete(value)
+  return out
+}
+
+const normalizeKnxAiAdapterHistoryEvent = ({ event, adapter, provider, nowTs = Date.now() } = {}) => {
+  const source = event && typeof event === 'object' && !Array.isArray(event) ? event : {}
+  const adapterSource = adapter && typeof adapter === 'object' ? adapter : {}
+  const providerSource = provider && typeof provider === 'object' ? provider : {}
+  const ts = parseTimestamp(source.ts || source.timestamp || source.at || source.start || source.date, nowTs)
+  const eventType = clampText(source.eventType || source.type || source.event || source.kind, 120)
+  if (!eventType) return null
+  const cameraId = clampText(source.cameraId || source.resourceId || source.deviceId, 200)
+  const cameraName = clampText(source.cameraName || source.resourceName || source.deviceName, 300)
+  const details = sanitizeHistoryValue(source.raw || source.details || source.metadata || {})
+  let detailsText = ''
+  try { detailsText = JSON.stringify(details) } catch (error) { detailsText = '' }
+  return {
+    ts,
+    at: new Date(ts).toISOString(),
+    adapterId: clampText(source.adapterId || providerSource.adapterId || adapterSource.id, 160),
+    adapterTitle: clampText(source.adapterTitle || adapterSource.title || adapterSource.name, 240),
+    providerId: clampText(source.providerId || providerSource.id, 220),
+    providerTitle: clampText(source.providerTitle || providerSource.title || providerSource.name, 240),
+    controllerId: clampText(source.controllerId || providerSource.controllerId, 180),
+    controllerName: clampText(source.controllerName || providerSource.controllerName, 240),
+    resourceType: clampText(source.resourceType || (cameraId || cameraName ? 'camera' : 'adapter'), 80),
+    resourceId: cameraId,
+    resourceName: cameraName,
+    eventType,
+    eventId: clampText(source.eventId || source.id, 200),
+    active: source.active !== false,
+    scopeId: clampText(source.scopeId, 180),
+    scopeName: clampText(source.scopeName, 240),
+    objectTypes: Array.from(new Set((Array.isArray(source.objectTypes) ? source.objectTypes : [])
+      .map(value => clampText(value, 100))
+      .filter(Boolean))).slice(0, 24),
+    details: detailsText.length <= KNX_AI_HISTORY_DETAILS_MAX_CHARS ? details : { truncated: true }
+  }
+}
+
+const HISTORY_STOP_WORDS = new Set([
+  'a', 'al', 'alla', 'alle', 'anche', 'and', 'auf', 'aux', 'avec', 'che', 'con', 'da', 'dal', 'dalla', 'das', 'de', 'dei', 'del', 'della', 'des', 'di', 'die', 'do', 'du', 'e', 'el', 'en', 'et', 'for', 'gli', 'ha', 'hanno', 'i', 'il', 'in', 'is', 'la', 'le', 'les', 'lo', 'mit', 'nel', 'nella', 'of', 'on', 'or', 'per', 'pour', 'que', 'qui', 'se', 'sono', 'su', 'the', 'to', 'tra', 'un', 'una', 'und', 'was', 'what', 'with', 'zu'
+])
+
+const historyQuestionTokens = question => Array.from(new Set(normalizeSearchText(question)
+  .split(/\s+/)
+  .filter(token => token.length >= 2 && !HISTORY_STOP_WORDS.has(token) && !/^\d{1,4}$/.test(token))))
+  .slice(0, 24)
+
+const incrementCount = (map, key) => {
+  const normalized = clampText(key, 500) || '(unknown)'
+  map.set(normalized, Number(map.get(normalized) || 0) + 1)
+}
+
+const topCounts = (map, limit) => Array.from(map.entries())
+  .map(([key, count]) => ({ key, count }))
+  .sort((left, right) => right.count - left.count || left.key.localeCompare(right.key))
+  .slice(0, Math.max(1, Number(limit) || 1))
+
+const buildEventSearchText = (event, kind) => {
+  if (kind === 'knx') {
+    return normalizeSearchText([
+      event.event,
+      event.source,
+      event.destination,
+      event.devicename,
+      event.dpt,
+      event.payloadmeasureunit,
+      typeof event.payload === 'object' ? JSON.stringify(event.payload) : event.payload
+    ].join(' '))
+  }
+  return normalizeSearchText([
+    event.adapterId,
+    event.adapterTitle,
+    event.providerId,
+    event.providerTitle,
+    event.controllerId,
+    event.controllerName,
+    event.resourceType,
+    event.resourceId,
+    event.resourceName,
+    event.eventType,
+    event.scopeId,
+    event.scopeName,
+    ...(Array.isArray(event.objectTypes) ? event.objectTypes : []),
+    event.details && typeof event.details === 'object' ? JSON.stringify(event.details) : ''
+  ].join(' '))
+}
+
+const buildKnxAiHistoryEventKey = (event, kind = 'adapter') => {
+  if (!event || typeof event !== 'object') return ''
+  if (kind === 'knx') {
+    let payload = ''
+    try { payload = typeof event.payload === 'object' ? JSON.stringify(event.payload) : String(event.payload) } catch (error) { payload = '' }
+    return [Number(event.ts || 0), event.event, event.source, event.destination, payload, event.rawHex].join('|')
+  }
+  return [Number(event.ts || 0), event.adapterId, event.providerId, event.resourceId, event.eventType, event.eventId, event.scopeId, (event.objectTypes || []).join(',')].join('|')
+}
+
+const createKnxAiHistoryAccumulator = ({ kind = 'adapter', question = '', limit = 120 } = {}) => {
+  const normalizedKind = kind === 'knx' ? 'knx' : 'adapter'
+  const maxItems = Math.max(1, Number(limit) || 120)
+  const tokens = historyQuestionTokens(question)
+  const recent = []
+  const relevant = []
+  const counts = {
+    byEvent: new Map(),
+    bySource: new Map(),
+    byResource: new Map(),
+    byObjectType: new Map(),
+    byCombination: new Map()
+  }
+  let total = 0
+  let active = 0
+  let firstTs = 0
+  let lastTs = 0
+
+  const add = event => {
+    if (!event || typeof event !== 'object') return
+    const ts = Number(event.ts || new Date(event.at || '').getTime() || 0)
+    if (!Number.isFinite(ts) || ts <= 0) return
+    total += 1
+    if (event.active !== false) active += 1
+    firstTs = firstTs > 0 ? Math.min(firstTs, ts) : ts
+    lastTs = Math.max(lastTs, ts)
+    const eventName = normalizedKind === 'knx' ? event.event : event.eventType
+    const sourceName = normalizedKind === 'knx'
+      ? event.source
+      : (event.adapterTitle || event.adapterId || event.providerTitle || event.providerId)
+    const resourceName = normalizedKind === 'knx'
+      ? `${event.destination || '?'}${event.devicename ? ` (${event.devicename})` : ''}`
+      : (event.resourceName || event.resourceId || event.controllerName || event.controllerId)
+    incrementCount(counts.byEvent, eventName)
+    incrementCount(counts.bySource, sourceName)
+    incrementCount(counts.byResource, resourceName)
+    ;(Array.isArray(event.objectTypes) ? event.objectTypes : []).forEach(value => incrementCount(counts.byObjectType, value))
+    const combination = normalizedKind === 'knx'
+      ? `${resourceName || '?'} | ${eventName || '?'} | ${clampText(typeof event.payload === 'object' ? JSON.stringify(event.payload) : event.payload, 160)}`
+      : `${resourceName || '?'} | ${eventName || '?'}${event.scopeName ? ` | ${event.scopeName}` : ''}${event.objectTypes && event.objectTypes.length ? ` | ${event.objectTypes.join(',')}` : ''}`
+    incrementCount(counts.byCombination, combination)
+
+    recent.push(event)
+    if (recent.length > maxItems) recent.shift()
+    if (tokens.length) {
+      const haystack = buildEventSearchText(event, normalizedKind)
+      let score = 0
+      tokens.forEach(token => { if (haystack.includes(token)) score += token.length + 2 })
+      if (score > 0) {
+        relevant.push({ event, score, ts })
+        if (relevant.length > maxItems * 4) {
+          relevant.sort((left, right) => right.score - left.score || right.ts - left.ts)
+          relevant.length = maxItems * 2
+        }
+      }
+    }
+  }
+
+  const finish = () => {
+    let events = recent
+    if (relevant.length) {
+      const selected = relevant
+        .sort((left, right) => right.score - left.score || right.ts - left.ts)
+        .slice(0, maxItems)
+        .map(item => item.event)
+      events = selected.sort((left, right) => Number(left.ts || 0) - Number(right.ts || 0))
+    }
+    return {
+      events,
+      summary: {
+        kind: normalizedKind,
+        totalEvents: total,
+        activeEvents: active,
+        inactiveEvents: total - active,
+        firstAt: firstTs ? new Date(firstTs).toISOString() : '',
+        lastAt: lastTs ? new Date(lastTs).toISOString() : '',
+        selection: relevant.length ? 'question-relevant' : 'most-recent',
+        selectedEvents: events.length,
+        byEvent: topCounts(counts.byEvent, 20),
+        bySource: topCounts(counts.bySource, 12),
+        byResource: topCounts(counts.byResource, 30),
+        byObjectType: topCounts(counts.byObjectType, 20),
+        byCombination: topCounts(counts.byCombination, 40)
+      }
+    }
+  }
+
+  return { add, finish }
+}
+
+const formatKnxAiAdapterHistoryEventForPrompt = event => {
+  if (!event || typeof event !== 'object') return ''
+  const resource = event.resourceName || event.resourceId || event.controllerName || event.controllerId || '?'
+  const scope = event.scopeName || event.scopeId
+  const objects = Array.isArray(event.objectTypes) && event.objectTypes.length ? event.objectTypes.join(',') : ''
+  return `${event.at || new Date(event.ts || Date.now()).toISOString()} | adapter ${event.adapterTitle || event.adapterId || '?'} | ${event.resourceType || 'resource'} ${resource} | ${event.eventType || '?'} | ${event.active === false ? 'inactive' : 'active'}${scope ? ` | scope ${scope}` : ''}${objects ? ` | objects ${objects}` : ''}`
+}
+
+module.exports = {
+  KNX_AI_ADAPTER_HISTORY_MIN_HOURS,
+  KNX_AI_HISTORY_DETAILS_MAX_CHARS,
+  buildKnxAiHistoryEventKey,
+  createKnxAiHistoryAccumulator,
+  formatKnxAiAdapterHistoryEventForPrompt,
+  normalizeKnxAiAdapterHistoryEvent,
+  sanitizeHistoryValue
+}

package/package.json

@@ -3,7 +3,7 @@
   "engines": {
     "node": ">=20.18.1"
   },
-  "version": "6.3.19",
+  "version": "6.3.22",
   "description": "KNX Ultimate is the most advanced KNX integration for Node-RED, providing secure KNX/IP communication, routing, ETS project import, Philips Hue, Matter Controller and Matter Bridge (control matter device via KNX and expose KNX GA via Matter), MQTT, diagnostics with AI, virtual devices, and powerful automation nodes. Build professional, reliable, and scalable smart home and building automation projects with minimal effort.",
   "files": [
     "nodes/",