@vainplex/openclaw-knowledge-engine 0.1.0

package/dist/src/llm-enhancer.js

@@ -0,0 +1,166 @@
+// src/llm-enhancer.ts
+import { httpPost } from './http-client.js';
+/**
+ * Manages batched requests to an external LLM for entity and fact extraction.
+ */
+export class LlmEnhancer {
+    config;
+    logger;
+    batch = [];
+    cooldownTimeout = null;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+    }
+    /**
+     * Adds a message to the current batch.
+     * Triggers a batch send (with proper error handling) when the size is reached.
+     */
+    addToBatch(item) {
+        if (!this.config.enabled)
+            return;
+        this.batch.push(item);
+        this.logger.debug(`Added message ${item.id} to LLM batch. Current size: ${this.batch.length}`);
+        if (this.batch.length >= this.config.batchSize) {
+            this.logger.info(`LLM batch size reached (${this.config.batchSize}). Sending immediately.`);
+            // S1: properly await and catch errors from sendBatch
+            this.sendBatch().catch(err => {
+                this.logger.error('Error sending LLM batch.', err);
+            });
+        }
+        else {
+            this.resetCooldownTimer();
+        }
+    }
+    /** Resets the cooldown timer. When it expires the batch is sent. */
+    resetCooldownTimer() {
+        if (this.cooldownTimeout)
+            clearTimeout(this.cooldownTimeout);
+        this.cooldownTimeout = setTimeout(() => {
+            if (this.batch.length > 0) {
+                this.logger.info('LLM cooldown expired. Sending batch.');
+                this.sendBatch().catch(err => {
+                    this.logger.error('Error sending LLM batch on cooldown.', err);
+                });
+            }
+        }, this.config.cooldownMs);
+        this.cooldownTimeout.unref();
+    }
+    /**
+     * Clears all pending timers. Called during shutdown.
+     */
+    clearTimers() {
+        if (this.cooldownTimeout) {
+            clearTimeout(this.cooldownTimeout);
+            this.cooldownTimeout = null;
+        }
+    }
+    /**
+     * Sends the current batch to the LLM for processing.
+     */
+    async sendBatch() {
+        this.clearTimers();
+        if (this.batch.length === 0)
+            return null;
+        const currentBatch = [...this.batch];
+        this.batch = [];
+        const prompt = this.constructPrompt(currentBatch);
+        try {
+            const responseJson = await this.makeHttpRequest(prompt);
+            const result = this.parseLlmResponse(responseJson);
+            const entities = this.transformToEntities(result.entities);
+            const facts = this.transformToFacts(result.facts);
+            this.logger.info(`LLM extracted ${entities.length} entities and ${facts.length} facts.`);
+            return { entities, facts };
+        }
+        catch (err) {
+            this.logger.error('Failed to send or process LLM batch.', err);
+            return null;
+        }
+    }
+    /** Constructs the prompt to be sent to the LLM. */
+    constructPrompt(batch) {
+        const conversation = batch.map(item => item.text).join('\n');
+        return [
+            'Analyze the following conversation and extract key entities and facts.',
+            'Respond with a single JSON object containing "entities" and "facts".',
+            '',
+            'For "entities", provide objects with "type", "value", and "importance".',
+            'Valid types: "person", "location", "organization", "product", "concept".',
+            '',
+            'For "facts", provide triples (subject, predicate, object).',
+            '',
+            'Conversation:',
+            '---',
+            conversation,
+            '---',
+            '',
+            'JSON Response:',
+        ].join('\n');
+    }
+    /** Makes an HTTP(S) request to the configured LLM endpoint. */
+    makeHttpRequest(prompt) {
+        return httpPost(this.config.endpoint, {
+            model: this.config.model,
+            prompt,
+            stream: false,
+            format: 'json',
+        });
+    }
+    /** Parses and validates the JSON response from the LLM. */
+    parseLlmResponse(responseJson) {
+        try {
+            const outer = JSON.parse(responseJson);
+            const inner = typeof outer.response === 'string'
+                ? outer.response : JSON.stringify(outer);
+            const data = JSON.parse(inner);
+            if (!data || typeof data !== 'object') {
+                throw new Error('LLM response is not a valid object.');
+            }
+            return {
+                entities: Array.isArray(data.entities) ? data.entities : [],
+                facts: Array.isArray(data.facts) ? data.facts : [],
+            };
+        }
+        catch (err) {
+            this.logger.error(`Failed to parse LLM response: ${responseJson}`, err);
+            throw new Error('Invalid JSON response from LLM.');
+        }
+    }
+    /** Transforms raw LLM entity data into the standard Entity format. */
+    transformToEntities(rawEntities) {
+        const entities = [];
+        for (const raw of rawEntities) {
+            const r = raw;
+            if (typeof r.value !== 'string' || typeof r.type !== 'string')
+                continue;
+            const value = r.value.trim();
+            const type = r.type.toLowerCase();
+            const id = `${type}:${value.toLowerCase().replace(/\s+/g, '-')}`;
+            const imp = typeof r.importance === 'number'
+                ? Math.max(0, Math.min(1, r.importance)) : 0.7;
+            entities.push({
+                id, value, type: type,
+                mentions: [value], count: 1, importance: imp,
+                lastSeen: new Date().toISOString(), source: ['llm'],
+            });
+        }
+        return entities;
+    }
+    /** Transforms raw LLM fact data into partial Fact objects. */
+    transformToFacts(rawFacts) {
+        const facts = [];
+        for (const raw of rawFacts) {
+            const r = raw;
+            if (typeof r.subject !== 'string' || typeof r.predicate !== 'string' || typeof r.object !== 'string')
+                continue;
+            facts.push({
+                subject: r.subject.trim(),
+                predicate: r.predicate.trim().toLowerCase().replace(/\s+/g, '-'),
+                object: r.object.trim(),
+                source: 'extracted-llm',
+            });
+        }
+        return facts;
+    }
+}

package/dist/src/maintenance.d.ts

@@ -0,0 +1,26 @@
+import { Embeddings } from './embeddings.js';
+import { FactStore } from './fact-store.js';
+import { KnowledgeConfig, Logger } from './types.js';
+/**
+ * Manages background maintenance tasks for the knowledge engine,
+ * such as decaying fact relevance and syncing embeddings.
+ */
+export declare class Maintenance {
+    private readonly config;
+    private readonly logger;
+    private readonly factStore;
+    private readonly embeddings?;
+    private decayTimer;
+    private embeddingsTimer;
+    constructor(config: KnowledgeConfig, logger: Logger, factStore: FactStore, embeddings?: Embeddings);
+    /** Starts all configured maintenance timers. */
+    start(): void;
+    /** Stops all running maintenance timers. */
+    stop(): void;
+    private startDecayTimer;
+    private startEmbeddingsTimer;
+    /** Executes the fact decay process. */
+    runDecay(): void;
+    /** Executes the embeddings synchronization process. */
+    runEmbeddingsSync(): Promise<void>;
+}

package/dist/src/maintenance.js

@@ -0,0 +1,87 @@
+// src/maintenance.ts
+/**
+ * Manages background maintenance tasks for the knowledge engine,
+ * such as decaying fact relevance and syncing embeddings.
+ */
+export class Maintenance {
+    config;
+    logger;
+    factStore;
+    embeddings;
+    decayTimer = null;
+    embeddingsTimer = null;
+    constructor(config, logger, factStore, embeddings) {
+        this.config = config;
+        this.logger = logger;
+        this.factStore = factStore;
+        this.embeddings = embeddings;
+    }
+    /** Starts all configured maintenance timers. */
+    start() {
+        this.logger.info('Starting maintenance service...');
+        this.stop();
+        this.startDecayTimer();
+        this.startEmbeddingsTimer();
+    }
+    /** Stops all running maintenance timers. */
+    stop() {
+        if (this.decayTimer) {
+            clearInterval(this.decayTimer);
+            this.decayTimer = null;
+        }
+        if (this.embeddingsTimer) {
+            clearInterval(this.embeddingsTimer);
+            this.embeddingsTimer = null;
+        }
+        this.logger.info('Stopped maintenance service.');
+    }
+    startDecayTimer() {
+        if (!this.config.decay.enabled)
+            return;
+        const ms = this.config.decay.intervalHours * 60 * 60 * 1000;
+        this.decayTimer = setInterval(() => this.runDecay(), ms);
+        this.decayTimer.unref();
+        this.logger.info(`Scheduled fact decay every ${this.config.decay.intervalHours} hours.`);
+    }
+    startEmbeddingsTimer() {
+        if (!this.embeddings?.isEnabled())
+            return;
+        const ms = this.config.embeddings.syncIntervalMinutes * 60 * 1000;
+        this.embeddingsTimer = setInterval(() => this.runEmbeddingsSync(), ms);
+        this.embeddingsTimer.unref();
+        this.logger.info(`Scheduled embeddings sync every ${this.config.embeddings.syncIntervalMinutes} min.`);
+    }
+    /** Executes the fact decay process. */
+    runDecay() {
+        this.logger.info('Running scheduled fact decay...');
+        try {
+            const { decayedCount } = this.factStore.decayFacts(this.config.decay.rate);
+            this.logger.info(`Fact decay complete. Decayed ${decayedCount} facts.`);
+        }
+        catch (err) {
+            this.logger.error('Error during fact decay.', err);
+        }
+    }
+    /** Executes the embeddings synchronization process. */
+    async runEmbeddingsSync() {
+        if (!this.embeddings?.isEnabled())
+            return;
+        this.logger.info('Running scheduled embeddings sync...');
+        try {
+            const unembedded = this.factStore.getUnembeddedFacts();
+            if (unembedded.length === 0) {
+                this.logger.info('No new facts to sync for embeddings.');
+                return;
+            }
+            const synced = await this.embeddings.sync(unembedded);
+            if (synced > 0) {
+                const ids = unembedded.slice(0, synced).map(f => f.id);
+                this.factStore.markFactsAsEmbedded(ids);
+                this.logger.info(`Embeddings sync complete. Synced ${synced} facts.`);
+            }
+        }
+        catch (err) {
+            this.logger.error('Error during embeddings sync.', err);
+        }
+    }
+}

package/dist/src/patterns.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A collection of regular expression factories for extracting entities.
+ * Each property access creates a fresh RegExp to avoid /g state-bleed.
+ */
+export declare const REGEX_PATTERNS: Record<string, RegExp>;

package/dist/src/patterns.js

@@ -0,0 +1,69 @@
+// src/patterns.ts
+/**
+ * Common words that look like proper nouns (start of sentence) but are not.
+ */
+const EXCLUDED_WORDS = [
+    'A', 'An', 'The', 'Hello', 'My', 'This', 'Contact', 'He', 'She',
+    'It', 'We', 'They', 'I', 'You', 'His', 'Her', 'Our', 'Your',
+    'Their', 'Its', 'That', 'These', 'Those', 'What', 'Which', 'Who',
+    'How', 'When', 'Where', 'Why', 'But', 'And', 'Or', 'So', 'Not',
+    'No', 'Yes', 'Also', 'Just', 'For', 'From', 'With', 'About',
+    'After', 'Before', 'Between', 'During', 'Into', 'Through',
+    'Event', 'Talk', 'Project', 'Multiple', 'German',
+    'Am', 'Are', 'Is', 'Was', 'Were', 'Has', 'Have',
+    'Had', 'Do', 'Does', 'Did', 'Will', 'Would', 'Could', 'Should',
+    'May', 'Might', 'Must', 'Can', 'Shall', 'If', 'Then',
+];
+const EXCL = EXCLUDED_WORDS.map(w => `${w}\\b`).join('|');
+/** Capitalized word: handles O'Malley, McDonald's, acronyms like USS */
+const CAP = `(?:[A-Z][a-z']*(?:[A-Z][a-z']+)*|[A-Z]{2,})`;
+const DE_MONTHS = 'Januar|Februar|März|Mar|April|Mai|Juni|Juli|August|September|Oktober|November|Dezember';
+const EN_MONTHS = 'January|February|March|April|May|June|July|August|September|October|November|December';
+/** Proper noun: one or more cap-words with exclusion list applied per word. */
+function properNounFactory() {
+    return new RegExp(`\\b(?!${EXCL})${CAP}(?:(?:-|\\s)(?!${EXCL})${CAP})*\\b`, 'g');
+}
+/** Product name: three branches for multi-word+Roman, word+version, camelCase. */
+function productNameFactory() {
+    return new RegExp(`\\b(?:(?!${EXCL})[A-Z][a-zA-Z0-9]{2,}(?:\\s[a-zA-Z]+)*\\s[IVXLCDM]+` +
+        `|[a-zA-Z][a-zA-Z0-9-]{2,}[\\s-]v?\\d+(?:\\.\\d+)?` +
+        `|[a-zA-Z][a-zA-Z0-9]+[IVXLCDM]+)\\b`, 'g');
+}
+/** Creates a fresh RegExp factory for each pattern key. */
+function buildPatterns() {
+    return {
+        email: () => /\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b/g,
+        url: () => /\bhttps?:\/\/[^\s/$.?#].[^\s]*\b/g,
+        iso_date: () => /\b\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d+)?Z?)?\b/g,
+        common_date: () => /\b(?:\d{1,2}\/\d{1,2}\/\d{2,4})|(?:\d{1,2}\.\d{1,2}\.\d{2,4})\b/g,
+        german_date: () => new RegExp(`\\b\\d{1,2}\\.\\s(?:${DE_MONTHS})\\s+\\d{4}\\b`, 'gi'),
+        english_date: () => new RegExp(`\\b(?:${EN_MONTHS})\\s+\\d{1,2}(?:st|nd|rd|th)?,\\s+\\d{4}\\b`, 'gi'),
+        proper_noun: properNounFactory,
+        product_name: productNameFactory,
+        organization_suffix: () => new RegExp('\\b(?:[A-Z][A-Za-z0-9]+(?:\\s[A-Z][A-Za-z0-9]+)*),?\\s?' +
+            '(?:Inc\\.|LLC|Corp\\.|GmbH|AG|Ltd\\.)', 'g'),
+    };
+}
+const PATTERN_FACTORIES = buildPatterns();
+/**
+ * A collection of regular expression factories for extracting entities.
+ * Each property access creates a fresh RegExp to avoid /g state-bleed.
+ */
+export const REGEX_PATTERNS = new Proxy({}, {
+    get(_target, prop) {
+        const factory = PATTERN_FACTORIES[prop];
+        return factory ? factory() : undefined;
+    },
+    ownKeys() {
+        return Object.keys(PATTERN_FACTORIES);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+        if (prop in PATTERN_FACTORIES) {
+            return { configurable: true, enumerable: true, writable: false };
+        }
+        return undefined;
+    },
+    has(_target, prop) {
+        return prop in PATTERN_FACTORIES;
+    },
+});

package/dist/src/storage.d.ts

@@ -0,0 +1,41 @@
+import { IStorage, Logger } from './types.js';
+/**
+ * A utility class for performing atomic and durable file I/O operations.
+ * It writes to a temporary file first, then renames it to the final destination,
+ * which prevents data corruption in case of a crash during the write.
+ */
+export declare class AtomicStorage implements IStorage {
+    private readonly storagePath;
+    private readonly logger;
+    /**
+     * Creates an instance of AtomicStorage.
+     * @param storagePath The base directory where files will be stored.
+     * @param logger A logger instance for logging errors.
+     */
+    constructor(storagePath: string, logger: Logger);
+    /**
+     * Ensures that the storage directory exists.
+     */
+    init(): Promise<void>;
+    /**
+     * Reads and parses a JSON file from the storage path.
+     * @param fileName The name of the file to read (e.g., "facts.json").
+     * @returns The parsed JSON object, or null if the file doesn't exist or is invalid.
+     */
+    readJson<T>(fileName: string): Promise<T | null>;
+    /**
+     * Writes a JSON object to a file atomically.
+     * @param fileName The name of the file to write (e.g., "facts.json").
+     * @param data The JSON object to serialize and write.
+     */
+    writeJson<T>(fileName: string, data: T): Promise<void>;
+    /**
+     * A debouncer function to limit the rate at which a function is executed.
+     * This version is designed for async functions and returns a promise that
+     * resolves with the result of the last invocation.
+     * @param func The async function to debounce.
+     * @param delay The debounce delay in milliseconds.
+     * @returns A debounced version of the function that returns a promise.
+     */
+    static debounce<A extends unknown[], R>(func: (...args: A) => Promise<R>, delay: number): (...args: A) => Promise<R>;
+}

package/dist/src/storage.js

@@ -0,0 +1,110 @@
+// src/storage.ts
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+/** Type guard for Node.js system errors with a `code` property. */
+function isNodeError(err) {
+    return err instanceof Error && 'code' in err;
+}
+/**
+ * A utility class for performing atomic and durable file I/O operations.
+ * It writes to a temporary file first, then renames it to the final destination,
+ * which prevents data corruption in case of a crash during the write.
+ */
+export class AtomicStorage {
+    storagePath;
+    logger;
+    /**
+     * Creates an instance of AtomicStorage.
+     * @param storagePath The base directory where files will be stored.
+     * @param logger A logger instance for logging errors.
+     */
+    constructor(storagePath, logger) {
+        this.storagePath = storagePath;
+        this.logger = logger;
+    }
+    /**
+     * Ensures that the storage directory exists.
+     */
+    async init() {
+        try {
+            await fs.mkdir(this.storagePath, { recursive: true });
+        }
+        catch (err) {
+            this.logger.error(`Failed to create storage directory: ${this.storagePath}`, err);
+            throw err;
+        }
+    }
+    /**
+     * Reads and parses a JSON file from the storage path.
+     * @param fileName The name of the file to read (e.g., "facts.json").
+     * @returns The parsed JSON object, or null if the file doesn't exist or is invalid.
+     */
+    async readJson(fileName) {
+        const filePath = path.join(this.storagePath, fileName);
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (err) {
+            if (isNodeError(err) && err.code === 'ENOENT') {
+                return null;
+            }
+            this.logger.error(`Failed to read or parse JSON file: ${filePath}`, err);
+            return null;
+        }
+    }
+    /**
+     * Writes a JSON object to a file atomically.
+     * @param fileName The name of the file to write (e.g., "facts.json").
+     * @param data The JSON object to serialize and write.
+     */
+    async writeJson(fileName, data) {
+        const filePath = path.join(this.storagePath, fileName);
+        const tempFilePath = `${filePath}.${Date.now()}.tmp`;
+        try {
+            const jsonString = JSON.stringify(data, null, 2);
+            await fs.writeFile(tempFilePath, jsonString, 'utf-8');
+            await fs.rename(tempFilePath, filePath);
+        }
+        catch (err) {
+            this.logger.error(`Failed to write JSON file atomically: ${filePath}`, err);
+            // Attempt to clean up the temporary file if it exists
+            try {
+                await fs.unlink(tempFilePath);
+            }
+            catch (cleanupErr) {
+                if (!isNodeError(cleanupErr) || cleanupErr.code !== 'ENOENT') {
+                    this.logger.warn(`Failed to clean up temporary file: ${tempFilePath}`);
+                }
+            }
+            throw err; // Re-throw the original error
+        }
+    }
+    /**
+     * A debouncer function to limit the rate at which a function is executed.
+     * This version is designed for async functions and returns a promise that
+     * resolves with the result of the last invocation.
+     * @param func The async function to debounce.
+     * @param delay The debounce delay in milliseconds.
+     * @returns A debounced version of the function that returns a promise.
+     */
+    static debounce(func, delay) {
+        let timeoutId = null;
+        let resolvers = [];
+        return (...args) => {
+            if (timeoutId)
+                clearTimeout(timeoutId);
+            const promise = new Promise((resolve, reject) => {
+                resolvers.push({ resolve, reject });
+            });
+            timeoutId = setTimeout(() => {
+                const current = resolvers;
+                resolvers = [];
+                func(...args)
+                    .then(result => current.forEach(r => r.resolve(result)))
+                    .catch(err => current.forEach(r => r.reject(err)));
+            }, delay);
+            return promise;
+        };
+    }
+}

package/dist/src/types.d.ts

@@ -0,0 +1,122 @@
+/**
+ * The public API exposed by the OpenClaw host to the plugin.
+ * This is a subset of the full API, containing only what this plugin needs.
+ */
+export interface OpenClawPluginApi {
+    pluginConfig: Record<string, unknown>;
+    logger: Logger;
+    on: (event: string, handler: (event: HookEvent, ctx: HookContext) => void, options?: {
+        priority: number;
+    }) => void;
+}
+/**
+ * A generic logger interface compatible with OpenClaw's logger.
+ */
+export interface Logger {
+    info: (msg: string) => void;
+    warn: (msg: string) => void;
+    error: (msg: string, err?: Error) => void;
+    debug: (msg: string) => void;
+}
+/**
+ * Represents the data payload for an OpenClaw hook.
+ * It's a generic shape, as different hooks have different payloads.
+ */
+export interface HookEvent {
+    content?: string;
+    message?: string;
+    text?: string;
+    from?: string;
+    sender?: string;
+    role?: "user" | "assistant";
+    [key: string]: unknown;
+}
+/**
+ * Represents the context object passed with each hook event.
+ */
+export interface HookContext {
+    workspace: string;
+}
+/**
+ * The fully resolved and validated plugin configuration object.
+ */
+export interface KnowledgeConfig {
+    enabled: boolean;
+    workspace: string;
+    extraction: {
+        regex: {
+            enabled: boolean;
+        };
+        llm: {
+            enabled: boolean;
+            model: string;
+            endpoint: string;
+            batchSize: number;
+            cooldownMs: number;
+        };
+    };
+    decay: {
+        enabled: boolean;
+        intervalHours: number;
+        rate: number;
+    };
+    embeddings: {
+        enabled: boolean;
+        endpoint: string;
+        collectionName: string;
+        syncIntervalMinutes: number;
+    };
+    storage: {
+        maxEntities: number;
+        maxFacts: number;
+        writeDebounceMs: number;
+    };
+}
+/**
+ * Represents an extracted entity.
+ */
+export interface Entity {
+    id: string;
+    type: "person" | "location" | "organization" | "date" | "product" | "concept" | "email" | "url" | "unknown";
+    value: string;
+    mentions: string[];
+    count: number;
+    importance: number;
+    lastSeen: string;
+    source: ("regex" | "llm")[];
+}
+/**
+ * Represents a structured fact (a triple).
+ */
+export interface Fact {
+    id: string;
+    subject: string;
+    predicate: string;
+    object: string;
+    relevance: number;
+    createdAt: string;
+    lastAccessed: string;
+    source: "ingested" | "extracted-regex" | "extracted-llm";
+    embedded?: string;
+}
+/**
+ * The data structure for the entities.json file.
+ */
+export interface EntitiesData {
+    updated: string;
+    entities: Entity[];
+}
+/**
+ * The data structure for the facts.json file.
+ */
+export interface FactsData {
+    updated: string;
+    facts: Fact[];
+}
+/**
+ * Interface for a generic file storage utility.
+ */
+export interface IStorage {
+    readJson<T>(fileName: string): Promise<T | null>;
+    writeJson<T>(fileName: string, data: T): Promise<void>;
+}

package/dist/src/types.js

@@ -0,0 +1,2 @@
+// src/types.ts
+export {};

package/index.ts

@@ -0,0 +1,38 @@
+// index.ts
+
+import { resolveConfig } from './src/config.js';
+import { HookManager } from './src/hooks.js';
+import type { OpenClawPluginApi } from './src/types.js';
+
+// The main entry point for the OpenClaw plugin.
+// This function is called by the OpenClaw host during plugin loading.
+export default (api: OpenClawPluginApi, context: { workspace: string }): void => {
+  const { pluginConfig, logger } = api;
+  const { workspace: openClawWorkspace } = context;
+
+  // 1. Resolve and validate the configuration
+  const config = resolveConfig(pluginConfig, logger, openClawWorkspace);
+
+  if (!config) {
+    logger.error('Failed to initialize Knowledge Engine: Invalid configuration. The plugin will be disabled.');
+    return;
+  }
+
+  if (!config.enabled) {
+    logger.info('Knowledge Engine is disabled in the configuration.');
+    return;
+  }
+
+  // 2. Initialize the Hook Manager with the resolved config
+  try {
+    const hookManager = new HookManager(api, config);
+    
+    // 3. Register all the event hooks
+    hookManager.registerHooks();
+
+    logger.info('Knowledge Engine plugin initialized successfully.');
+    
+  } catch (err) {
+    logger.error('An unexpected error occurred during Knowledge Engine initialization.', err as Error);
+  }
+};