node-red-contrib-knx-ultimate 6.3.21 → 6.3.24

package/nodes/utils/knxAiChatContext.js

@@ -1,4 +1,4 @@
-const CHAT_CONTEXT_VERSION = 1
+const CHAT_CONTEXT_VERSION = 3
 const CHAT_CONTEXT_MAX_BYTES = 512 * 1024
 const CHAT_CONTEXT_MAX_SESSIONS = 50
 const CHAT_CONTEXT_MAX_TURNS_PER_SESSION = 8
@@ -7,6 +7,7 @@ const CHAT_CONTEXT_MAX_CAMERA_WATCHES_PER_SESSION = 20
 const CHAT_CONTEXT_MAX_QUESTION_CHARS = 4000
 const CHAT_CONTEXT_MAX_REPLY_CHARS = 8000
 const CHAT_CONTEXT_MAX_INSTRUCTION_CHARS = 2000
+const CHAT_CONTEXT_NATIVE_HEADER = 'KNXAI_CHAT_CONTEXT'
 
 const clampText = (value, maxChars) => String(value === undefined || value === null ? '' : value)
   .trim()
@@ -126,45 +127,36 @@ const touchSession = (context, sessionId) => {
   return { target, session }
 }
 
-const explicitInstructionPatterns = [
-  /^\s*(?:please[\s,]+)?remember\b/i,
-  /^\s*from now on\b/i,
-  /^\s*(?:please[\s,]+)?(?:always|never)\b/i,
-  /^\s*(?:per favore[\s,]+)?(?:ricordati|ricorda|ricordarsi|memorizza)\b/i,
-  /^\s*(?:d['’]ora in poi|da ora in poi)\b/i,
-  /^\s*(?:usa sempre|non usare mai|evita sempre)\b/i,
-  /^\s*(?:bitte[\s,]+)?(?:merk dir|erinnere dich)\b/i,
-  /^\s*(?:ab jetzt|von jetzt an)\b/i,
-  /^\s*(?:s['’]il te pla[iî]t[\s,]+)?(?:souviens-toi|rappelle-toi|m[eé]morise)\b/i,
-  /^\s*(?:dor[eé]navant|[àa] partir de maintenant)\b/i,
-  /^\s*(?:por favor[\s,]+)?(?:recuerda|memoriza)\b/i,
-  /^\s*(?:a partir de ahora|de ahora en adelante)\b/i,
-  /^\s*(?:请)?记住/,
-  /^\s*从现在开始/
-]
-
-const extractExplicitKnxAiChatInstruction = (question) => {
-  const text = clampText(question, CHAT_CONTEXT_MAX_INSTRUCTION_CHARS)
-  if (!text) return ''
-  return explicitInstructionPatterns.some(pattern => pattern.test(text)) ? text : ''
-}
-
 const addKnxAiChatTurn = (context, { sessionId, question, reply, at } = {}) => {
   const { target, session } = touchSession(context, sessionId)
   const turn = normalizeTurn({ at, question, reply })
   if (turn) session.turns.push(turn)
   session.turns = session.turns.slice(-CHAT_CONTEXT_MAX_TURNS_PER_SESSION)
+  return target
+}
 
-  const explicitInstruction = extractExplicitKnxAiChatInstruction(question)
-  if (explicitInstruction) {
-    const normalized = explicitInstruction.toLocaleLowerCase()
-    session.instructions = session.instructions.filter(item => item.text.toLocaleLowerCase() !== normalized)
-    session.instructions.push({
-      at: clampText(at || new Date().toISOString(), 64),
-      text: explicitInstruction
-    })
-    session.instructions = session.instructions.slice(-CHAT_CONTEXT_MAX_INSTRUCTIONS_PER_SESSION)
+const addKnxAiChatInstruction = (context, { sessionId, text, at } = {}) => {
+  const instruction = normalizeInstruction({ text, at })
+  if (!instruction) return normalizeKnxAiChatContext(context)
+  const { target, session } = touchSession(context, sessionId)
+  const normalizedText = instruction.text.toLocaleLowerCase()
+  session.instructions = session.instructions
+    .filter(item => item.text.toLocaleLowerCase() !== normalizedText)
+  session.instructions.push(instruction)
+  session.instructions = session.instructions.slice(-CHAT_CONTEXT_MAX_INSTRUCTIONS_PER_SESSION)
+  return target
+}
+
+const removeKnxAiChatInstructions = (context, { sessionId, text, all = false } = {}) => {
+  const { target, session } = touchSession(context, sessionId)
+  if (all === true) {
+    session.instructions = []
+    return target
   }
+  const normalizedText = clampText(text, CHAT_CONTEXT_MAX_INSTRUCTION_CHARS).toLocaleLowerCase()
+  if (!normalizedText) return target
+  session.instructions = session.instructions
+    .filter(item => item.text.toLocaleLowerCase() !== normalizedText)
   return target
 }
 
@@ -217,7 +209,7 @@ const buildKnxAiChatPromptContext = ({ context, sessionId, maxChars = 16000 } =
   if (!session.instructions.length && !session.turns.length && !session.cameraWatches.length) return ''
   const lines = []
   if (session.instructions.length) {
-    lines.push('PERSISTENT CHAT INSTRUCTIONS AND PREFERENCES (explicitly supplied by this user; follow them unless they conflict with safety or the KNX contract; newer entries override older conflicting entries):')
+    lines.push('PERSISTENT USER-PROVIDED FACTS, PREFERENCES, AND INSTRUCTIONS (follow relevant entries unless they conflict with safety or the KNX contract; newer entries override older conflicting entries):')
     session.instructions.forEach(item => lines.push(`- ${item.text.replace(/\r?\n/g, ' ')}`))
   }
   if (session.turns.length) {
@@ -241,56 +233,75 @@ const buildKnxAiChatPromptContext = ({ context, sessionId, maxChars = 16000 } =
   return lines.join('\n').slice(0, Math.max(1000, Number(maxChars) || 16000))
 }
 
-const escapeMarkdownText = value => clampText(value, CHAT_CONTEXT_MAX_REPLY_CHARS)
-  .replace(/\r?\n/g, ' ')
-  .replace(/</g, '&lt;')
-  .replace(/>/g, '&gt;')
+const escapeKnxAiChatContextField = value => String(value === undefined || value === null ? '' : value)
+  .replace(/\\/g, '\\\\')
+  .replace(/\t/g, '\\t')
+  .replace(/\r/g, '\\r')
+  .replace(/\n/g, '\\n')
 
-const renderKnxAiChatContext = (context) => {
+const unescapeKnxAiChatContextField = (value) => {
+  const source = String(value === undefined || value === null ? '' : value)
+  let result = ''
+  for (let index = 0; index < source.length; index += 1) {
+    const char = source[index]
+    if (char !== '\\' || index + 1 >= source.length) {
+      result += char
+      continue
+    }
+    const next = source[index + 1]
+    if (next === '\\') result += '\\'
+    else if (next === 't') result += '\t'
+    else if (next === 'r') result += '\r'
+    else if (next === 'n') result += '\n'
+    else result += `\\${next}`
+    index += 1
+  }
+  return result
+}
+
+const buildKnxAiChatContextRecord = (type, fields = []) => [type]
+  .concat(fields.map(escapeKnxAiChatContextField))
+  .join('\t')
+
+const renderKnxAiChatContextFile = (context) => {
   const target = normalizeKnxAiChatContext(context)
   target.updatedAt = new Date().toISOString()
-  const metadata = Buffer.from(JSON.stringify(target), 'utf8').toString('base64')
   const lines = [
-    '<!-- KNX_AI_CHAT_CONTEXT_V1_BASE64',
-    metadata,
-    'KNX_AI_CHAT_CONTEXT_END -->',
-    '',
-    '# KNX AI Chat Context',
-    '',
-    `Updated: ${target.updatedAt}`,
-    '',
-    'This bounded file stores recent chat turns and explicit long-term instructions separately for each chat session.',
-    ''
+    '# KNX AI native chat-learning context',
+    '# Tab-separated records. Escapes: \\\\ (backslash), \\t (tab), \\n (newline), \\r (carriage return).',
+    '# Records: SESSION, INSTRUCTION, TURN, CAMERA_WATCH, END_SESSION.',
+    buildKnxAiChatContextRecord(CHAT_CONTEXT_NATIVE_HEADER, [CHAT_CONTEXT_VERSION]),
+    buildKnxAiChatContextRecord('CREATED_AT', [target.createdAt]),
+    buildKnxAiChatContextRecord('UPDATED_AT', [target.updatedAt])
   ]
   target.sessions.forEach((session) => {
-    lines.push(`## Session ${escapeMarkdownText(session.id)}`, '')
-    lines.push('### Persistent instructions', '')
-    if (!session.instructions.length) lines.push('_None._')
-    session.instructions.forEach(item => lines.push(`- ${escapeMarkdownText(item.at)} — ${escapeMarkdownText(item.text)}`))
-    lines.push('', '### Camera watches', '')
-    if (!session.cameraWatches.length) lines.push('_None._')
+    lines.push(buildKnxAiChatContextRecord('SESSION', [session.id, session.updatedAt]))
+    session.instructions.forEach(item => lines.push(buildKnxAiChatContextRecord('INSTRUCTION', [item.at, item.text])))
+    session.turns.forEach(turn => lines.push(buildKnxAiChatContextRecord('TURN', [turn.at, turn.question, turn.reply])))
     session.cameraWatches.forEach((watch) => {
-      const camera = watch.cameraName || watch.cameraId
-      const scope = watch.scopeName || watch.scopeId
-      const objects = watch.objectTypes.length ? `; objects ${watch.objectTypes.join(', ')}` : ''
-      lines.push(`- ${escapeMarkdownText(watch.id)} — ${escapeMarkdownText(camera)}; event ${escapeMarkdownText(watch.eventType)}${scope ? `; scope ${escapeMarkdownText(scope)}` : ''}${objects}; cooldown ${watch.cooldownSeconds}s`)
-    })
-    lines.push('', '### Recent turns', '')
-    if (!session.turns.length) lines.push('_None._')
-    session.turns.forEach((turn) => {
-      lines.push(`- ${escapeMarkdownText(turn.at)} — **User:** ${escapeMarkdownText(turn.question)}`)
-      lines.push(`  **Assistant:** ${escapeMarkdownText(turn.reply)}`)
+      lines.push(buildKnxAiChatContextRecord('CAMERA_WATCH', [
+        watch.id,
+        watch.createdAt,
+        watch.cameraId,
+        watch.cameraName,
+        watch.eventType,
+        watch.scopeId,
+        watch.scopeName,
+        watch.cooldownSeconds,
+        watch.sendSnapshot ? 'true' : 'false',
+        watch.language
+      ].concat(watch.objectTypes)))
     })
-    lines.push('')
+    lines.push('END_SESSION')
   })
-  return { markdown: lines.join('\n'), context: target }
+  return { content: `${lines.join('\n')}\n`, context: target }
 }
 
-const buildKnxAiChatContextMarkdown = ({ context, maxBytes = CHAT_CONTEXT_MAX_BYTES } = {}) => {
+const buildKnxAiChatContextFile = ({ context, maxBytes = CHAT_CONTEXT_MAX_BYTES } = {}) => {
   const targetBytes = Math.max(64 * 1024, Math.min(CHAT_CONTEXT_MAX_BYTES, Number(maxBytes) || CHAT_CONTEXT_MAX_BYTES))
   let bounded = normalizeKnxAiChatContext(context)
-  let rendered = renderKnxAiChatContext(bounded)
-  while (Buffer.byteLength(rendered.markdown, 'utf8') > targetBytes) {
+  let rendered = renderKnxAiChatContextFile(bounded)
+  while (Buffer.byteLength(rendered.content, 'utf8') > targetBytes) {
     const sessionWithTurns = bounded.sessions.find(session => session.turns.length > 0)
     if (sessionWithTurns) sessionWithTurns.turns.shift()
     else if (bounded.sessions.length > 1) bounded.sessions.shift()
@@ -299,24 +310,108 @@ const buildKnxAiChatContextMarkdown = ({ context, maxBytes = CHAT_CONTEXT_MAX_BY
       if (!sessionWithInstructions) break
       sessionWithInstructions.instructions.shift()
     }
-    rendered = renderKnxAiChatContext(bounded)
+    rendered = renderKnxAiChatContextFile(bounded)
     bounded = rendered.context
   }
   return {
-    markdown: rendered.markdown,
+    content: rendered.content,
     context: rendered.context,
-    bytes: Buffer.byteLength(rendered.markdown, 'utf8'),
+    bytes: Buffer.byteLength(rendered.content, 'utf8'),
     maxBytes: targetBytes
   }
 }
 
-const parseKnxAiChatContextMarkdown = (markdown) => {
-  const text = String(markdown || '')
-  const match = text.match(/<!-- KNX_AI_CHAT_CONTEXT_V1_BASE64\s*\n([A-Za-z0-9+/=\r\n]+?)\nKNX_AI_CHAT_CONTEXT_END -->/)
-  if (!match) return createEmptyKnxAiChatContext()
+const parseKnxAiChatContextFileStrict = (content) => {
+  const source = String(content || '')
+  const context = { version: CHAT_CONTEXT_VERSION, createdAt: '', updatedAt: '', sessions: [] }
+  let headerSeen = false
+  let currentSession = null
+
+  source.split(/\r?\n/).forEach((line, lineIndex) => {
+    if (!line.trim() || line.trimStart().startsWith('#')) return
+    const fields = line.split('\t').map(unescapeKnxAiChatContextField)
+    const record = fields.shift()
+    const fail = message => { throw new Error(`Invalid KNX AI native chat-learning context at line ${lineIndex + 1}: ${message}`) }
+
+    if (!headerSeen) {
+      if (record !== CHAT_CONTEXT_NATIVE_HEADER || String(fields[0] || '') !== String(CHAT_CONTEXT_VERSION)) {
+        fail(`expected ${CHAT_CONTEXT_NATIVE_HEADER} ${CHAT_CONTEXT_VERSION} header`)
+      }
+      headerSeen = true
+      return
+    }
+
+    if (record === 'CREATED_AT') {
+      if (currentSession) fail('CREATED_AT is not allowed inside a session')
+      context.createdAt = fields[0] || ''
+      return
+    }
+    if (record === 'UPDATED_AT') {
+      if (currentSession) fail('UPDATED_AT is not allowed inside a session')
+      context.updatedAt = fields[0] || ''
+      return
+    }
+    if (record === 'SESSION') {
+      if (currentSession) fail('nested SESSION record')
+      if (!String(fields[0] || '').trim()) fail('SESSION id is required')
+      currentSession = {
+        id: fields[0],
+        updatedAt: fields[1] || '',
+        turns: [],
+        instructions: [],
+        cameraWatches: []
+      }
+      return
+    }
+    if (record === 'END_SESSION') {
+      if (!currentSession) fail('END_SESSION without SESSION')
+      context.sessions.push(currentSession)
+      currentSession = null
+      return
+    }
+    if (!currentSession) fail(`${record || 'empty record'} is not allowed outside a session`)
+    if (record === 'INSTRUCTION') {
+      if (fields.length < 2 || !String(fields[1] || '').trim()) fail('INSTRUCTION requires timestamp and text')
+      currentSession.instructions.push({ at: fields[0], text: fields[1] })
+      return
+    }
+    if (record === 'TURN') {
+      if (fields.length < 3 || (!String(fields[1] || '').trim() && !String(fields[2] || '').trim())) {
+        fail('TURN requires timestamp, question and reply')
+      }
+      currentSession.turns.push({ at: fields[0], question: fields[1], reply: fields[2] })
+      return
+    }
+    if (record === 'CAMERA_WATCH') {
+      if (fields.length < 10) fail('CAMERA_WATCH has missing fields')
+      if (fields[8] !== 'true' && fields[8] !== 'false') fail('CAMERA_WATCH sendSnapshot must be true or false')
+      currentSession.cameraWatches.push({
+        id: fields[0],
+        createdAt: fields[1],
+        cameraId: fields[2],
+        cameraName: fields[3],
+        eventType: fields[4],
+        scopeId: fields[5],
+        scopeName: fields[6],
+        cooldownSeconds: Number(fields[7]),
+        sendSnapshot: fields[8] === 'true',
+        language: fields[9],
+        objectTypes: fields.slice(10)
+      })
+      return
+    }
+    fail(`unknown ${record || 'empty'} record`)
+  })
+
+  if (!headerSeen) throw new Error(`The file does not contain a ${CHAT_CONTEXT_NATIVE_HEADER} ${CHAT_CONTEXT_VERSION} header`)
+  if (currentSession) throw new Error('Invalid KNX AI native chat-learning context: SESSION without END_SESSION')
+  if (!context.createdAt || !context.updatedAt) throw new Error('Invalid KNX AI native chat-learning context: CREATED_AT and UPDATED_AT are required')
+  return normalizeKnxAiChatContext(context)
+}
+
+const parseKnxAiChatContextFile = (content) => {
   try {
-    const metadata = Buffer.from(match[1].replace(/\s+/g, ''), 'base64').toString('utf8')
-    return normalizeKnxAiChatContext(JSON.parse(metadata))
+    return parseKnxAiChatContextFileStrict(content)
   } catch (error) {
     return createEmptyKnxAiChatContext()
   }
@@ -340,18 +435,20 @@ module.exports = {
   CHAT_CONTEXT_MAX_SESSIONS,
   CHAT_CONTEXT_MAX_TURNS_PER_SESSION,
   addKnxAiCameraWatch,
+  addKnxAiChatInstruction,
   addKnxAiChatTurn,
-  buildKnxAiChatContextMarkdown,
+  buildKnxAiChatContextFile,
   buildKnxAiChatPromptContext,
   clearKnxAiChatSession,
   conversationMapFromKnxAiChatContext,
   createEmptyKnxAiChatContext,
-  extractExplicitKnxAiChatInstruction,
   getKnxAiChatSession,
   listAllKnxAiCameraWatches,
   listKnxAiCameraWatches,
   normalizeKnxAiChatContext,
   normalizeCameraWatch,
-  parseKnxAiChatContextMarkdown,
-  removeKnxAiCameraWatches
+  parseKnxAiChatContextFile,
+  parseKnxAiChatContextFileStrict,
+  removeKnxAiCameraWatches,
+  removeKnxAiChatInstructions
 }

package/nodes/utils/knxAiEventHistory.js

@@ -1,5 +1,19 @@
 const KNX_AI_ADAPTER_HISTORY_MIN_HOURS = 24
 const KNX_AI_HISTORY_DETAILS_MAX_CHARS = 12000
+const KNX_AI_COMPACT_ARCHIVE_EXTENSION = 'knxctx'
+
+const KNX_AI_COMPACT_ARCHIVE_COLUMNS = Object.freeze({
+  knx: Object.freeze([
+    'ts', 'event', 'source', 'destination', 'dpt', 'devicename', 'payload',
+    'payloadmeasureunit', 'echoed', 'repeated', 'rawHex', 'dptdesc'
+  ]),
+  adapter: Object.freeze([
+    'ts', 'adapterId', 'adapterTitle', 'providerId', 'providerTitle',
+    'controllerId', 'controllerName', 'resourceType', 'resourceId',
+    'resourceName', 'eventType', 'eventId', 'active', 'scopeId', 'scopeName',
+    'objectTypes', 'details'
+  ])
+})
 
 const clampText = (value, maxChars = 500) => String(value === undefined || value === null ? '' : value)
   .trim()
@@ -42,6 +56,259 @@ const sanitizeHistoryValue = (value, depth = 0, seen = new Set()) => {
   return out
 }
 
+const encodeCompactText = value => encodeURIComponent(String(value === undefined || value === null ? '' : value))
+  .replace(/[!'()*]/g, char => `%${char.charCodeAt(0).toString(16).toUpperCase()}`)
+
+const decodeCompactText = value => {
+  try { return decodeURIComponent(String(value || '')) } catch (error) { return String(value || '') }
+}
+
+const encodeKnxAiCompactValue = (value, depth = 0, seen = new Set()) => {
+  if (value === undefined) return 'u'
+  if (value === null) return 'z'
+  if (typeof value === 'boolean') return value ? 'b1' : 'b0'
+  if (typeof value === 'number') return Number.isFinite(value) ? `n${value}` : 'u'
+  if (typeof value === 'bigint') return `s${encodeCompactText(String(value))}`
+  if (typeof value === 'string') return `s${encodeCompactText(value)}`
+  if (Buffer.isBuffer(value)) return `x${value.toString('base64')}`
+  if (typeof value !== 'object') return `s${encodeCompactText(String(value))}`
+  if (depth >= 4 || seen.has(value)) return `s${encodeCompactText('[nested]')}`
+  seen.add(value)
+  if (Array.isArray(value)) {
+    const encoded = value.slice(0, 40).map(item => encodeKnxAiCompactValue(item, depth + 1, seen))
+    seen.delete(value)
+    return `a(${encoded.join(',')})`
+  }
+  const encoded = Object.keys(value).slice(0, 80).map(key => (
+    `${encodeCompactText(key)}=${encodeKnxAiCompactValue(value[key], depth + 1, seen)}`
+  ))
+  seen.delete(value)
+  return `o(${encoded.join(';')})`
+}
+
+const decodeKnxAiCompactValue = value => {
+  const source = String(value || '')
+  let offset = 0
+  const readUntil = delimiters => {
+    const start = offset
+    while (offset < source.length && !delimiters.includes(source[offset])) offset += 1
+    return source.slice(start, offset)
+  }
+  const parseValue = () => {
+    const tag = source[offset]
+    offset += 1
+    if (tag === 'u') return undefined
+    if (tag === 'z') return null
+    if (tag === 'b') {
+      const bool = source[offset] === '1'
+      offset += 1
+      return bool
+    }
+    if (tag === 'n') {
+      const parsed = Number(readUntil([',', ';', ')']))
+      return Number.isFinite(parsed) ? parsed : undefined
+    }
+    if (tag === 's') return decodeCompactText(readUntil([',', ';', ')']))
+    if (tag === 'x') {
+      const encoded = readUntil([',', ';', ')'])
+      try { return Buffer.from(encoded, 'base64') } catch (error) { return encoded }
+    }
+    if (tag === 'a' && source[offset] === '(') {
+      offset += 1
+      const out = []
+      while (offset < source.length && source[offset] !== ')') {
+        out.push(parseValue())
+        if (source[offset] === ',') offset += 1
+        else if (source[offset] !== ')') break
+      }
+      if (source[offset] === ')') offset += 1
+      return out
+    }
+    if (tag === 'o' && source[offset] === '(') {
+      offset += 1
+      const out = {}
+      while (offset < source.length && source[offset] !== ')') {
+        const key = decodeCompactText(readUntil(['=']))
+        if (source[offset] !== '=') break
+        offset += 1
+        out[key] = parseValue()
+        if (source[offset] === ';') offset += 1
+        else if (source[offset] !== ')') break
+      }
+      if (source[offset] === ')') offset += 1
+      return out
+    }
+    return decodeCompactText(source.slice(Math.max(0, offset - 1)))
+  }
+  try { return parseValue() } catch (error) { return source }
+}
+
+const escapeKnxAiCompactField = value => String(value === undefined || value === null ? '' : value)
+  .replace(/\\/g, '\\\\')
+  .replace(/\t/g, '\\t')
+  .replace(/\r/g, '\\r')
+  .replace(/\n/g, '\\n')
+
+const unescapeKnxAiCompactField = value => String(value || '').replace(/\\([\\tnr])/g, (match, escaped) => {
+  if (escaped === 't') return '\t'
+  if (escaped === 'r') return '\r'
+  if (escaped === 'n') return '\n'
+  return '\\'
+})
+
+const serializeKnxAiCompactHistoryRecord = (event, kind = 'adapter') => {
+  if (!event || typeof event !== 'object') return ''
+  const normalizedKind = kind === 'knx' ? 'knx' : 'adapter'
+  const values = normalizedKind === 'knx'
+    ? [
+        Number(event.ts || 0),
+        event.event,
+        event.source,
+        event.destination,
+        event.dpt,
+        event.devicename,
+        encodeKnxAiCompactValue(sanitizeHistoryValue(event.payload)),
+        event.payloadmeasureunit,
+        event.echoed === true ? 1 : 0,
+        event.repeated === true ? 1 : 0,
+        event.rawHex,
+        event.dptdesc
+      ]
+    : [
+        Number(event.ts || 0),
+        event.adapterId,
+        event.adapterTitle,
+        event.providerId,
+        event.providerTitle,
+        event.controllerId,
+        event.controllerName,
+        event.resourceType,
+        event.resourceId,
+        event.resourceName,
+        event.eventType,
+        event.eventId,
+        event.active === false ? 0 : 1,
+        event.scopeId,
+        event.scopeName,
+        encodeKnxAiCompactValue(Array.isArray(event.objectTypes) ? event.objectTypes : []),
+        encodeKnxAiCompactValue(sanitizeHistoryValue(event.details || {}))
+      ]
+  return values.map(escapeKnxAiCompactField).join('\t')
+}
+
+const parseKnxAiCompactHistoryRecord = (line, kind = 'adapter') => {
+  const source = String(line || '')
+  if (!source.trim()) return null
+  const normalizedKind = kind === 'knx' ? 'knx' : 'adapter'
+  const values = source.split('\t').map(unescapeKnxAiCompactField)
+  const columns = KNX_AI_COMPACT_ARCHIVE_COLUMNS[normalizedKind]
+  if (values.length !== columns.length) return null
+  const ts = Number(values[0])
+  if (!Number.isFinite(ts) || ts <= 0) return null
+  if (normalizedKind === 'knx') {
+    return {
+      ts,
+      event: values[1],
+      source: values[2],
+      destination: values[3],
+      dpt: values[4],
+      devicename: values[5],
+      payload: decodeKnxAiCompactValue(values[6]),
+      payloadmeasureunit: values[7],
+      echoed: values[8] === '1',
+      repeated: values[9] === '1',
+      rawHex: values[10] || undefined,
+      dptdesc: values[11]
+    }
+  }
+  const objectTypes = decodeKnxAiCompactValue(values[15])
+  const details = decodeKnxAiCompactValue(values[16])
+  return {
+    ts,
+    at: new Date(ts).toISOString(),
+    adapterId: values[1],
+    adapterTitle: values[2],
+    providerId: values[3],
+    providerTitle: values[4],
+    controllerId: values[5],
+    controllerName: values[6],
+    resourceType: values[7],
+    resourceId: values[8],
+    resourceName: values[9],
+    eventType: values[10],
+    eventId: values[11],
+    active: values[12] !== '0',
+    scopeId: values[13],
+    scopeName: values[14],
+    objectTypes: Array.isArray(objectTypes) ? objectTypes : [],
+    details: details && typeof details === 'object' ? details : {}
+  }
+}
+
+const compactPromptScalar = value => String(value === undefined || value === null ? '-' : value)
+  .replace(/[\r\n\t]+/g, ' ')
+  .replace(/\|/g, '\\|')
+  .trim()
+
+const formatKnxAiCompactContextForPrompt = value => {
+  const lines = []
+  const walk = (current, path = '') => {
+    if (current === undefined || current === null || typeof current !== 'object') {
+      lines.push(`${path || 'value'}=${compactPromptScalar(current)}`)
+      return
+    }
+    if (Array.isArray(current)) {
+      if (current.every(item => item === null || item === undefined || typeof item !== 'object')) {
+        lines.push(`${path || 'values'}=${current.map(compactPromptScalar).join(',')}`)
+        return
+      }
+      current.forEach((item, index) => {
+        const itemPath = `${path || 'items'}[${index}]`
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+          walk(item, itemPath)
+          return
+        }
+        const scalarEntries = Object.entries(item).filter(([, child]) => child === null || child === undefined || typeof child !== 'object')
+        if (scalarEntries.length) {
+          lines.push(`${itemPath} ${scalarEntries.map(([key, child]) => `${key}=${compactPromptScalar(child)}`).join(' | ')}`)
+        }
+        Object.entries(item).filter(([, child]) => child && typeof child === 'object').forEach(([key, child]) => walk(child, `${itemPath}.${key}`))
+      })
+      return
+    }
+    Object.entries(current).forEach(([key, child]) => walk(child, path ? `${path}.${key}` : key))
+  }
+  walk(value)
+  return lines.join('\n')
+}
+
+const formatKnxAiHistorySummaryForPrompt = summary => {
+  const source = summary && typeof summary === 'object' ? summary : {}
+  const lines = [
+    [
+      `kind=${compactPromptScalar(source.kind)}`,
+      `total=${Number(source.totalEvents || 0)}`,
+      `active=${Number(source.activeEvents || 0)}`,
+      `inactive=${Number(source.inactiveEvents || 0)}`,
+      `first=${compactPromptScalar(source.firstAt)}`,
+      `last=${compactPromptScalar(source.lastAt)}`,
+      `selection=${compactPromptScalar(source.selection)}`,
+      `selected=${Number(source.selectedEvents || 0)}`
+    ].join(' | ')
+  ]
+  ;[
+    ['events', source.byEvent],
+    ['sources', source.bySource],
+    ['resources', source.byResource],
+    ['objects', source.byObjectType],
+    ['combinations', source.byCombination]
+  ].forEach(([label, items]) => {
+    const entries = (Array.isArray(items) ? items : []).map(item => `${compactPromptScalar(item && item.key)}=${Number(item && item.count || 0)}`)
+    if (entries.length) lines.push(`${label}: ${entries.join(' | ')}`)
+  })
+  return lines.join('\n')
+}
+
 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 : {}
@@ -237,10 +504,18 @@ const formatKnxAiAdapterHistoryEventForPrompt = event => {
 
 module.exports = {
   KNX_AI_ADAPTER_HISTORY_MIN_HOURS,
+  KNX_AI_COMPACT_ARCHIVE_COLUMNS,
+  KNX_AI_COMPACT_ARCHIVE_EXTENSION,
   KNX_AI_HISTORY_DETAILS_MAX_CHARS,
   buildKnxAiHistoryEventKey,
   createKnxAiHistoryAccumulator,
+  decodeKnxAiCompactValue,
+  encodeKnxAiCompactValue,
   formatKnxAiAdapterHistoryEventForPrompt,
+  formatKnxAiCompactContextForPrompt,
+  formatKnxAiHistorySummaryForPrompt,
   normalizeKnxAiAdapterHistoryEvent,
+  parseKnxAiCompactHistoryRecord,
+  serializeKnxAiCompactHistoryRecord,
   sanitizeHistoryValue
 }

package/package.json

@@ -3,7 +3,7 @@
   "engines": {
     "node": ">=20.18.1"
   },
-  "version": "6.3.21",
+  "version": "6.3.24",
   "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/",