@byted-las/contextlake-openclaw 1.0.0

package/src/commands/cli.ts

@@ -0,0 +1,77 @@
+// @ts-ignore
+import { PluginContext } from 'openclaw/plugin-sdk';
+import { ingestAssets } from '../lib/actions/ingest';
+import { retrieveAssets } from '../lib/actions/retrieve';
+import { listAssets, deleteAssets } from '../lib/actions/manage';
+
+export function getCliCommands(pluginConfig: any, logger: any) {
+    return {
+        ingestAction: async (files: any, options: any) => {
+            logger.info(`[${new Date().toISOString()}] [ContextLake] CLI ingest started`, { files, options });
+            try {
+                const metadata = options.metadata ? JSON.parse(options.metadata) : {};
+                const result = await ingestAssets({
+                    files,
+                    metadata,
+                    chunkSize: parseInt(options.chunkSize),
+                    overlap: parseInt(options.overlap)
+                }, pluginConfig, logger);
+                // eslint-disable-next-line no-console
+                console.log(JSON.stringify(result, null, 2));
+                logger.info(`[${new Date().toISOString()}] [ContextLake] CLI ingest success`);
+            } catch (e: any) {
+                console.error('Error:', e.message);
+                logger.error(`[${new Date().toISOString()}] [ContextLake] CLI ingest failed`, { error: e.message, stack: e.stack });
+            }
+        },
+
+        searchAction: async (query: any, options: any) => {
+            logger.info(`[${new Date().toISOString()}] [ContextLake] CLI search started`, { query, options });
+            try {
+                const result = await retrieveAssets({
+                    query,
+                    top_k: parseInt(options.topK),
+                    filter: options.filter,
+                    include_binary: options.binary
+                }, pluginConfig, logger);
+                // eslint-disable-next-line no-console
+                console.log(JSON.stringify(result, null, 2));
+                logger.info(`[${new Date().toISOString()}] [ContextLake] CLI search success`);
+            } catch (e: any) {
+                console.error('Error:', e.message);
+                logger.error(`[${new Date().toISOString()}] [ContextLake] CLI search failed`, { error: e.message, stack: e.stack });
+            }
+        },
+
+        listAction: async (options: any) => {
+            logger.info(`[${new Date().toISOString()}] [ContextLake] CLI list started`, { options });
+            try {
+                const result = await listAssets({
+                    limit: parseInt(options.limit)
+                }, pluginConfig, logger);
+                // eslint-disable-next-line no-console
+                console.log(JSON.stringify(result, null, 2));
+                logger.info(`[${new Date().toISOString()}] [ContextLake] CLI list success`);
+            } catch (e: any) {
+                console.error('Error:', e.message);
+                logger.error(`[${new Date().toISOString()}] [ContextLake] CLI list failed`, { error: e.message, stack: e.stack });
+            }
+        },
+
+        deleteAction: async (options: any) => {
+            logger.info(`[${new Date().toISOString()}] [ContextLake] CLI delete started`, { options });
+            try {
+                const result = await deleteAssets({
+                    file_ids: options.ids,
+                    filter: options.filter
+                }, pluginConfig, logger);
+                // eslint-disable-next-line no-console
+                console.log(JSON.stringify(result, null, 2));
+                logger.info(`[${new Date().toISOString()}] [ContextLake] CLI delete success`);
+            } catch (e: any) {
+                console.error('Error:', e.message);
+                logger.error(`[${new Date().toISOString()}] [ContextLake] CLI delete failed`, { error: e.message, stack: e.stack });
+            }
+        }
+    };
+}

package/src/commands/index.ts

@@ -0,0 +1,156 @@
+import { getAgentTools } from './tools';
+import { getCliCommands } from './cli';
+import { getSlashCommands } from './slashcmd';
+import { getPluginConfig } from '../utils/config';
+import { connectDataSource, ConnectParams } from '../skills/las-data-profiler';
+
+export function registerAll(ctx: any, logger: any) {
+    const pluginConfig = getPluginConfig(ctx);
+
+    // Register Agent Tools
+    try {
+        const tools = getAgentTools(pluginConfig, logger);
+        
+        ctx.registerTool(tools.ingestTool);
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.ingestTool.name}`);
+        
+        ctx.registerTool(tools.retrieveTool);
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.retrieveTool.name}`);
+        
+        ctx.registerTool(tools.listTool);
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.listTool.name}`);
+        
+        ctx.registerTool(tools.deleteTool);
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.deleteTool.name}`);
+        
+    } catch (error: any) {
+        logger.error(`[${new Date().toISOString()}] [ContextLake] Error registering agent tools: ${error.message}`, { stack: error.stack });
+        throw error;
+    }
+
+    // Register CLI
+    try {
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Registering CLI commands`);
+        ctx.registerCli((cliContext: any) => {
+            const program = cliContext.program;
+            const contextlake = program.command('contextlake')
+                .description('Manage ContextLake knowledge base');
+            
+            const commands = getCliCommands(pluginConfig, logger);
+            
+            // connect -- data source profiling (las-data-profiler)
+            contextlake.command('connect <datasource_name>')
+                .description('Connect to a data source and profile its structure, schemas, and media metadata into LanceDB')
+                .requiredOption('--vendor <vendor>', 'Data source type: volcengine | alibaba | tencent | aws | local')
+                .option('--endpoint <url>', 'S3 Endpoint URL (not needed for local)')
+                .option('--ak <credential_id>', 'Credential ID for the data source')
+                .option('--sk <credential_value>', 'Credential value for the data source')
+                .option('--region <region>', 'Region identifier (e.g. cn-beijing)')
+                .requiredOption('--bucket <bucket>', 'Bucket name (or local root directory for local vendor)')
+                .requiredOption('--prefix <prefix>', 'Path prefix to limit scan scope')
+                .option('--sample-rows <number>', 'Number of rows to sample per structured file', '100')
+                .action(async (datasource_name: string, options: any) => {
+                    try {
+                        const params: ConnectParams = {
+                            datasource_name,
+                            vendor: options.vendor,
+                            endpoint: options.endpoint,
+                            access_key: options.ak,
+                            secret_key: options.sk,
+                            region: options.region,
+                            bucket: options.bucket,
+                            prefix: options.prefix,
+                            sample_rows: parseInt(options.sampleRows),
+                        };
+
+                        console.log(`[contextlake connect] Connecting to datasource "${datasource_name}"...`);
+                        console.log(`  vendor: ${params.vendor}`);
+                        console.log(`  bucket: ${params.bucket}`);
+                        console.log(`  prefix: ${params.prefix}`);
+
+                        const result = await connectDataSource(params);
+                        console.log(JSON.stringify(result, null, 2));
+                    } catch (e: any) {
+                        console.error('Error:', e.message);
+                        process.exitCode = 1;
+                    }
+                });
+
+            // Ingest
+            contextlake.command('ingest <files...>')
+                .description('Ingest one or more files into the knowledge base')
+                .option('-c, --chunk-size <number>', 'Chunk size for text splitting', '500')
+                .option('-o, --overlap <number>', 'Chunk overlap size', '50')
+                .option('-m, --metadata <json>', 'JSON metadata to attach to the documents')
+                .action(commands.ingestAction);
+
+            // Search
+            contextlake.command('search <query>')
+                .description('Search the knowledge base for relevant documents')
+                .option('-k, --top-k <number>', 'Number of top results to return', '5')
+                .option('-f, --filter <string>', 'Filter string for the search')
+                .option('-b, --binary', 'Include binary content in the result', false)
+                .action(commands.searchAction);
+
+            // List
+            contextlake.command('list')
+                .description('List documents currently in the knowledge base')
+                .option('-l, --limit <number>', 'Maximum number of results to return', '100')
+                .action(commands.listAction);
+
+            // Delete
+            contextlake.command('delete')
+                .description('Delete documents from the knowledge base')
+                .option('--ids <ids...>', 'List of specific file IDs to delete')
+                .option('-f, --filter <string>', 'Filter string to match documents for deletion')
+                .action(commands.deleteAction);
+                
+        }, { commands: ['contextlake'] });
+        logger.info(`[${new Date().toISOString()}] [ContextLake] CLI commands registered`);
+    } catch (error: any) {
+        logger.error(`[${new Date().toISOString()}] [ContextLake] Error registering CLI commands: ${error.message}`, { stack: error.stack });
+        throw error;
+    }
+    
+    // Register Slash Commands
+    try {
+        if (typeof ctx.registerCommand !== 'function') {
+            logger.warn(`[ContextLake] registerCommand is not available in current OpenClaw version, skipping slash commands registration.`);
+            return;
+        }
+
+        const slashCommands = getSlashCommands(pluginConfig, logger);
+        
+        ctx.registerCommand({
+            name: 'contextlake-ingest',
+            description: 'Ingest files into the knowledge base (usage: /contextlake-ingest file1 file2)',
+            acceptsArgs: true,
+            handler: slashCommands.ingestHandler
+        });
+
+        ctx.registerCommand({
+            name: 'contextlake-list',
+            description: 'List documents currently in the knowledge base',
+            acceptsArgs: true,
+            handler: slashCommands.listHandler
+        });
+
+        ctx.registerCommand({
+            name: 'contextlake-search',
+            description: 'Search the knowledge base for relevant documents',
+            acceptsArgs: true,
+            handler: slashCommands.searchHandler
+        });
+
+        ctx.registerCommand({
+            name: 'contextlake-delete',
+            description: 'Delete documents from the knowledge base by ID',
+            acceptsArgs: true,
+            handler: slashCommands.deleteHandler
+        });
+        
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Slash commands registered`);
+    } catch (error: any) {
+        logger.error(`[${new Date().toISOString()}] [ContextLake] Error registering Slash commands: ${error.message}`, { stack: error.stack });
+    }
+}

package/src/commands/slashcmd.ts

@@ -0,0 +1,95 @@
+// @ts-ignore
+import { PluginContext } from 'openclaw/plugin-sdk';
+import { ingestAssets } from '../lib/actions/ingest';
+import { retrieveAssets } from '../lib/actions/retrieve';
+import { listAssets, deleteAssets } from '../lib/actions/manage';
+
+export function getSlashCommands(pluginConfig: any, logger: any) {
+    return {
+        ingestHandler: async (commandCtx: any) => {
+            const rawArgs = commandCtx.args || "";
+            const args = rawArgs.split(' ').filter((arg: string) => arg.trim() !== '');
+
+            logger.info(`[${new Date().toISOString()}] [ContextLake] Slash command ingest started`, { args });
+            try {
+                if (args.length === 0) {
+                    return { text: `**Error:** Missing files. Usage: /contextlake-ingest /path/to/file1 /path/to/file2` };
+                }
+                const result = await ingestAssets({
+                    files: args,
+                    metadata: {}
+                }, pluginConfig, logger);
+                
+                logger.info(`[${new Date().toISOString()}] [ContextLake] Slash command ingest completed`, { resultCount: result.length });
+                return { text: `**Ingest Results (${result.length} files processed):**\n\`\`\`json\n${JSON.stringify(result, null, 2)}\n\`\`\`` };
+            } catch (e: any) {
+                logger.error(`[ContextLake] Slash ingest failed`, { error: e.message });
+                return { text: `**Error executing ingest:** ${e.message}` };
+            }
+        },
+
+        listHandler: async (commandCtx: any) => {
+            const rawArgs = commandCtx.args || "";
+            const args = rawArgs.split(' ').filter((arg: string) => arg.trim() !== '');
+
+            logger.info(`[${new Date().toISOString()}] [ContextLake] Slash command list started`, { args });
+            try {
+                let limit = 100;
+                if (args.length > 0 && !isNaN(parseInt(args[0]))) {
+                    limit = parseInt(args[0]);
+                }
+                const result = await listAssets({ limit }, pluginConfig, logger);
+                logger.info(`[${new Date().toISOString()}] [ContextLake] Slash command list completed`, { resultCount: result.length });
+                return { text: `**ContextLake Documents (${result.length}):**\n\`\`\`json\n${JSON.stringify(result, null, 2)}\n\`\`\`` };
+            } catch (e: any) {
+                logger.error(`[ContextLake] Slash list failed`, { error: e.message });
+                return { text: `**Error executing list:** ${e.message}` };
+            }
+        },
+
+        searchHandler: async (commandCtx: any) => {
+            const rawArgs = commandCtx.args || "";
+            const args = rawArgs.split(' ').filter((arg: string) => arg.trim() !== '');
+
+            logger.info(`[${new Date().toISOString()}] [ContextLake] Slash command search started`, { args });
+            try {
+                if (args.length === 0) {
+                    return { text: `**Error:** Missing search query. Usage: /contextlake-search "your query here"` };
+                }
+                const query = args.join(' ');
+                const result = await retrieveAssets({
+                    query,
+                    top_k: 5,
+                    filter: undefined,
+                    include_binary: false
+                }, pluginConfig, logger);
+                logger.info(`[${new Date().toISOString()}] [ContextLake] Slash command search completed`, { resultCount: result.length });
+                return { text: `**Search Results for "${query}" (${result.length}):**\n\`\`\`json\n${JSON.stringify(result, null, 2)}\n\`\`\`` };
+            } catch (e: any) {
+                logger.error(`[ContextLake] Slash search failed`, { error: e.message });
+                return { text: `**Error executing search:** ${e.message}` };
+            }
+        },
+
+        deleteHandler: async (commandCtx: any) => {
+            const rawArgs = commandCtx.args || "";
+            const args = rawArgs.split(' ').filter((arg: string) => arg.trim() !== '');
+
+            logger.info(`[${new Date().toISOString()}] [ContextLake] Slash command delete started`, { args });
+            try {
+                if (args.length === 0) {
+                    return { text: `**Error:** Missing file IDs. Usage: /contextlake-delete fileId1 fileId2` };
+                }
+                const result = await deleteAssets({
+                    file_ids: args,
+                    filter: undefined
+                }, pluginConfig, logger);
+                logger.info(`[${new Date().toISOString()}] [ContextLake] Slash command delete completed`, { result });
+                return { text: `**Delete Results:**\n\`\`\`json\n${JSON.stringify(result, null, 2)}\n\`\`\`` };
+            } catch (e: any) {
+                logger.error(`[ContextLake] Slash delete failed`, { error: e.message });
+                return { text: `**Error executing delete:** ${e.message}` };
+            }
+        }
+    };
+}

package/src/commands/tools.ts

@@ -0,0 +1,286 @@
+import { ingestAssets } from '../lib/actions/ingest';
+import { retrieveAssets } from '../lib/actions/retrieve';
+import { listAssets, deleteAssets } from '../lib/actions/manage';
+
+export function getAgentTools(pluginConfig: any, logger: any) {
+    return {
+        ingestTool: {
+            name: 'contextlake-ingest',
+            label: 'ContextLake Ingest',
+            description: `Upload, ingest, and index documents into the ContextLake Knowledge Base (知识库) / Knowledge Lake (知识湖).
+Use this tool when the user wants to "将知识注入", "上传文件", "入库", "添加文档", "ingest files", or "add knowledge".
+Supports processing of various file types including PDF, Word, Markdown, and Text.
+Automatically handles text extraction, cleaning, chunking, embedding generation, and storage.
+
+Example User Queries:
+- "帮我把这个文档注入到知识湖中"
+- "上传这份 PDF 到知识库"
+- "Please ingest these documents into ContextLake"
+- "将 /path/to/doc.txt 添加到知识库"`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    files: { 
+                        type: 'array', 
+                        items: { type: 'string' }, 
+                        description: 'List of file paths to ingest' 
+                    },
+                    metadata: { 
+                        type: 'object', 
+                        description: 'Optional JSON metadata to attach to documents',
+                        additionalProperties: true
+                    },
+                    chunkSize: { 
+                        type: 'integer', 
+                        description: 'Chunk size for text splitting' 
+                    },
+                    overlap: { 
+                        type: 'integer', 
+                        description: 'Overlap size for text splitting' 
+                    }
+                },
+                required: ['files'],
+                additionalProperties: false
+            },
+            schema: {
+                type: 'object',
+                properties: {
+                    files: { 
+                        type: 'array', 
+                        items: { type: 'string' }, 
+                        description: 'List of file paths to ingest' 
+                    },
+                    metadata: { 
+                        type: 'object', 
+                        description: 'Optional JSON metadata to attach to documents',
+                        additionalProperties: true
+                    },
+                    chunkSize: { 
+                        type: 'integer', 
+                        description: 'Chunk size for text splitting' 
+                    },
+                    overlap: { 
+                        type: 'integer', 
+                        description: 'Overlap size for text splitting' 
+                    }
+                },
+                required: ['files'],
+                additionalProperties: false
+            },
+            async execute(toolCallId: string, params: any) {
+                logger.info(`[${new Date().toISOString()}] [ContextLake] Executing ingest skill, toolCallId: ${toolCallId}`, { params: JSON.stringify(params) });
+
+                try {
+                    let actualParams = params;
+                    if (typeof params === 'string') {
+                        try {
+                            actualParams = JSON.parse(params);
+                        } catch (e) {
+                            logger.warn(`[ContextLake] Received string params, possibly toolCallId?`, { params });
+                            return {
+                                success: false,
+                                error: `Invalid params format: received string "${params}", expected object with 'files' array.`
+                            };
+                        }
+                    }
+                    
+                    if (!actualParams.files && actualParams.params && actualParams.params.files) {
+                        actualParams = actualParams.params;
+                    }
+
+                    if (!actualParams.files || !Array.isArray(actualParams.files)) {
+                        return {
+                            success: false,
+                            error: `Invalid params: 'files' must be an array. Received keys: ${Object.keys(actualParams)}`
+                        };
+                    }
+
+                    const result = await ingestAssets(actualParams, pluginConfig, logger);
+                    logger.info(`[${new Date().toISOString()}] [ContextLake] Ingest skill completed successfully`, { resultSummary: Array.isArray(result) ? `Processed ${result.length} items` : 'Success' });
+                    return {
+                        success: true,
+                        result
+                    };
+                } catch (error: any) {
+                    logger.error(`[${new Date().toISOString()}] [ContextLake] Ingest skill failed`, { error: error.message, stack: error.stack });
+                    return {
+                        success: false,
+                        error: error.message
+                    };
+                }
+            }
+        },
+        retrieveTool: {
+            name: 'contextlake-retrieve',
+            label: 'ContextLake Retrieve',
+            description: `Search, query, and retrieve relevant information from the ContextLake Knowledge Base (知识库) / Knowledge Lake (知识湖).
+Use this tool when the user wants to "搜索知识", "获取信息", "召回文档", "查询知识库", "search knowledge base", or "retrieve documents".
+Uses vector similarity search to find semantically related document chunks.
+
+Example User Queries:
+- "知识库里有关于产品安装的文档吗？"
+- "帮我从知识湖中召回关于财务报表的资料"
+- "Search the knowledge base for deployment guides"
+- "根据知识库内容，回答如何配置网关"`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'Search query' },
+                    top_k: { type: 'integer', description: 'Number of results to return' },
+                    filter: { type: 'string', description: 'Filter string' },
+                    include_binary: { type: 'boolean', description: 'Whether to include binary content' }
+                },
+                required: ['query'],
+                additionalProperties: false
+            },
+            schema: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'Search query' },
+                    top_k: { type: 'integer', description: 'Number of results to return' },
+                    filter: { type: 'string', description: 'Filter string' },
+                    include_binary: { type: 'boolean', description: 'Whether to include binary content' }
+                },
+                required: ['query'],
+                additionalProperties: false
+            },
+            async execute(toolCallId: string, params: any) {
+                logger.info(`[${new Date().toISOString()}] [ContextLake] Executing retrieve skill, toolCallId: ${toolCallId}`, { params: JSON.stringify(params) });
+                
+                try {
+                    let actualParams = params;
+                    if (typeof params === 'string') {
+                        try {
+                            actualParams = JSON.parse(params);
+                        } catch (e) {
+                            logger.warn(`[ContextLake] Received string params for retrieve, attempting fallback parsing`, { params });
+                            // For retrieve, if it's a string, maybe they just passed the query directly
+                            actualParams = { query: params };
+                        }
+                    } else if (params && params.params) {
+                        actualParams = params.params;
+                    }
+                    
+                    if (!actualParams || typeof actualParams.query !== 'string') {
+                         return {
+                             success: false,
+                             error: `Invalid params: 'query' is required and must be a string. Received: ${JSON.stringify(actualParams)}`
+                         };
+                    }
+
+                    const result = await retrieveAssets(actualParams, pluginConfig, logger);
+                    logger.info(`[${new Date().toISOString()}] [ContextLake] Retrieve skill completed`, { resultCount: Array.isArray(result) ? result.length : 0 });
+                    return {
+                        success: true,
+                        result
+                    };
+                } catch (error: any) {
+                    logger.error(`[${new Date().toISOString()}] [ContextLake] Retrieve skill failed`, { error: error.message, stack: error.stack });
+                    return {
+                        success: false,
+                        error: error.message
+                    };
+                }
+            }
+        },
+        listTool: {
+            name: 'contextlake-list',
+            label: 'ContextLake List',
+            description: `List documents and assets currently in the ContextLake Knowledge Base (知识库) / Knowledge Lake (知识湖).
+Use this tool when the user wants to "列出所有知识", "查看知识库文件", "显示文档列表", "list knowledge", or "show documents".
+
+Example User Queries:
+- "知识湖里目前有哪些文件？"
+- "列出前10个知识库文档"
+- "Show me all documents in the knowledge base"`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    limit: { type: 'integer', description: 'Limit for list action' }
+                },
+                required: [],
+                additionalProperties: false
+            },
+            schema: {
+                type: 'object',
+                properties: {
+                    limit: { type: 'integer', description: 'Limit for list action' }
+                },
+                required: []
+            },
+            async execute(toolCallId: string, params: any) {
+                logger.info(`[${new Date().toISOString()}] [ContextLake] Executing list skill, toolCallId: ${toolCallId}`, { params: JSON.stringify(params) });
+
+                try {
+                    let actualParams = params;
+                    if (params && params.params) {
+                        actualParams = params.params;
+                    }
+                    const result = await listAssets(actualParams, pluginConfig, logger);
+                    logger.info(`[${new Date().toISOString()}] [ContextLake] List skill completed`, { count: Array.isArray(result) ? result.length : 0 });
+                    return {
+                        success: true,
+                        result
+                    };
+                } catch (error: any) {
+                    logger.error(`[${new Date().toISOString()}] [ContextLake] List skill failed`, { error: error.message, stack: error.stack });
+                    return {
+                        success: false,
+                        error: error.message
+                    };
+                }
+            }
+        },
+        deleteTool: {
+            name: 'contextlake-delete',
+            label: 'ContextLake Delete',
+            description: `Delete documents and assets from the ContextLake Knowledge Base (知识库) / Knowledge Lake (知识湖).
+Use this tool when the user wants to "删除某个文档", "清理知识库", "移除文件", "delete knowledge", or "remove documents".
+Supports deleting documents by their specific IDs or by applying a SQL-like filter.
+
+Example User Queries:
+- "删除 ID 为 12345 的文档"
+- "Please delete the old architecture document from the knowledge base"
+- "从知识湖中移除 category 是 finance 的所有记录"`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    file_ids: { type: 'array', items: { type: 'string' }, description: 'File IDs to delete' },
+                    filter: { type: 'string', description: 'Filter string for deletion' }
+                },
+                required: [],
+                additionalProperties: false
+            },
+            schema: {
+                type: 'object',
+                properties: {
+                    file_ids: { type: 'array', items: { type: 'string' }, description: 'File IDs to delete' },
+                    filter: { type: 'string', description: 'Filter string for deletion' }
+                },
+                required: []
+            },
+            async execute(toolCallId: string, params: any) {
+                logger.info(`[${new Date().toISOString()}] [ContextLake] Executing delete skill, toolCallId: ${toolCallId}`, { params: JSON.stringify(params) });
+
+                try {
+                    let actualParams = params;
+                    if (params && params.params) {
+                        actualParams = params.params;
+                    }
+                    const result = await deleteAssets(actualParams, pluginConfig, logger);
+                    logger.info(`[${new Date().toISOString()}] [ContextLake] Delete skill completed`, { result });
+                    return {
+                        success: true,
+                        result
+                    };
+                } catch (error: any) {
+                    logger.error(`[${new Date().toISOString()}] [ContextLake] Delete skill failed`, { error: error.message, stack: error.stack });
+                    return {
+                        success: false,
+                        error: error.message
+                    };
+                }
+            }
+        }
+    };
+}