@byted-las/contextlake-openclaw 1.0.2 → 1.0.3

package/dist/src/lib/actions/las.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lasPdfParseDoubao = lasPdfParseDoubao;
+exports.lasLongVideoUnderstand = lasLongVideoUnderstand;
+exports.lasBareImageTextEmbedding = lasBareImageTextEmbedding;
+exports.lasSeed20 = lasSeed20;
+exports.lasAsrPro = lasAsrPro;
+exports.lasAudioExtractAndSplit = lasAudioExtractAndSplit;
+function getLASConfig(config) {
+    // Attempt to get from env vars or config
+    const endpoint = process.env.LAS_ENDPOINT || (config?.las)?.endpoint;
+    const apiKey = process.env.LAS_API_KEY || (config?.las)?.api_key;
+    if (!endpoint || !apiKey) {
+        throw new Error("LAS_ENDPOINT and LAS_API_KEY must be set in environment variables or config");
+    }
+    return { endpoint, apiKey };
+}
+async function lasFetch(path, payload, config) {
+    const { endpoint, apiKey } = getLASConfig(config);
+    const url = `${endpoint.replace(/\/$/, '')}${path}`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`
+        },
+        body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+        let errorText = await response.text().catch(() => '');
+        throw new Error(`LAS API Error: ${response.status} ${response.statusText} - ${errorText}`);
+    }
+    return await response.json();
+}
+async function lasPdfParseDoubao(params, config) {
+    return lasFetch('/api/v1/submit', {
+        operator_id: 'las_pdf_parse_doubao',
+        operator_version: 'v1',
+        data: params
+    }, config);
+}
+async function lasLongVideoUnderstand(params, config) {
+    return lasFetch('/api/v1/submit', {
+        operator_id: 'las_long_video_understand',
+        operator_version: 'v1',
+        data: params
+    }, config);
+}
+async function lasBareImageTextEmbedding(params, config) {
+    return lasFetch('/api/v1/embeddings/multimodal', {
+        model: 'doubao-embedding-vision',
+        input: params.input,
+        encoding_format: params.encoding_format
+    }, config);
+}
+async function lasSeed20(params, config) {
+    return lasFetch('/api/v1/chat/completions', params, config);
+}
+async function lasAsrPro(params, config) {
+    return lasFetch('/api/v1/submit', {
+        operator_id: 'las_asr_pro',
+        operator_version: 'v1',
+        data: params
+    }, config);
+}
+async function lasAudioExtractAndSplit(params, config) {
+    return lasFetch('/api/v1/process', {
+        operator_id: 'las_audio_extract_and_split',
+        operator_version: 'v1',
+        data: params
+    }, config);
+}

package/dist/src/lib/actions/profiler.d.ts

@@ -23,3 +23,6 @@ export interface ConnectResult {
     error?: string;
 }
 export declare function connectDataSource(params: ConnectParams, _ctx?: any): Promise<ConnectResult>;
+export declare function listDataSources(_ctx?: any): Promise<{
+    datasources: string[];
+}>;

package/dist/src/lib/actions/profiler.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.connectDataSource = connectDataSource;
+exports.listDataSources = listDataSources;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -41,7 +42,7 @@ const child_process_1 = require("child_process");
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
-const BASE_DIR = path.join(os.homedir(), '.openclaw', 'las-data-profiler');
+const BASE_DIR = path.join(os.homedir(), '.openclaw', 'contextlake', 'profiler');
 const PYTHON_DEPS = ['boto3', 'lancedb', 'pyarrow', 'pandas', 'Pillow', 'mutagen', 'pymupdf'];
 // ---------------------------------------------------------------------------
 // Helpers
@@ -229,3 +230,18 @@ async function connectDataSource(params, _ctx) {
         });
     });
 }
+async function listDataSources(_ctx) {
+    try {
+        if (!fs.existsSync(BASE_DIR)) {
+            return { datasources: [] };
+        }
+        const entries = fs.readdirSync(BASE_DIR, { withFileTypes: true });
+        const datasources = entries
+            .filter(entry => entry.isDirectory())
+            .map(entry => entry.name);
+        return { datasources };
+    }
+    catch (error) {
+        throw new Error(`Failed to list data sources: ${error.message}`);
+    }
+}

package/dist/src/lib/actions/retrieve.js

@@ -21,10 +21,7 @@ async function retrieveAssets(params, config, logger) {
     const results = await metadataProvider.search(params.query, params.top_k || 5, params.filter);
     if (params.include_binary) {
         const enrichedResults = await Promise.all(results.map(async (doc) => {
-            const { binary_data, ...rest } = doc;
-            if (rest.vector) {
-                rest.vector = Array.from(rest.vector);
-            }
+            const { binary_data, vector, ...rest } = doc;
             try {
                 if (rest.storage_type === 'inline') {
                     return {
@@ -53,10 +50,7 @@ async function retrieveAssets(params, config, logger) {
         return enrichedResults;
     }
     return results.map((doc) => {
-        const { binary_data, ...rest } = doc;
-        if (rest.vector) {
-            rest.vector = Array.from(rest.vector);
-        }
+        const { binary_data, vector, ...rest } = doc;
         const safeDoc = JSON.parse(JSON.stringify(rest));
         return safeDoc;
     });

package/dist/src/lib/scripts/s3_catalog.py

@@ -523,10 +523,19 @@ def main():
     parser.add_argument('--region', default='')
     parser.add_argument('--bucket', required=True)
     parser.add_argument('--prefix', required=True)
-    parser.add_argument('--db-path', default='./catalog_db')
+    parser.add_argument('--db-path', default=None, help='Path to LanceDB database. Defaults to ~/.openclaw/las-data-profiler/{datasource_name}/catalog_db if datasource_name is provided.')
+    parser.add_argument('--datasource-name', default='', help='Name of the datasource. Used to determine default db-path if not explicitly provided.')
     parser.add_argument('--sample-rows', type=int, default=100)
     args = parser.parse_args()
 
+    if not args.db_path:
+        if args.datasource_name:
+            import os
+            home_dir = os.path.expanduser('~')
+            args.db_path = os.path.join(home_dir, '.openclaw', 'las-data-profiler', args.datasource_name, 'catalog_db')
+        else:
+            args.db_path = './catalog_db'
+
     print(f"[las-data-profiler] vendor={args.vendor}, bucket={args.bucket}, prefix={args.prefix}")
     print(f"[las-data-profiler] db_path={args.db_path}")
 

package/dist/src/service/embedding/factory.js

@@ -1,16 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createEmbeddingProvider = createEmbeddingProvider;
-const local_1 = require("./local");
 const remote_1 = require("./remote");
 function createEmbeddingProvider(config) {
-    if (config.provider === 'local') {
-        return new local_1.LocalEmbeddingProvider(config);
-    }
-    else if (config.provider === 'openai' || config.provider === 'remote' || config.provider === 'las') {
-        return new remote_1.RemoteEmbeddingProvider(config);
-    }
-    else {
-        throw new Error(`Unsupported embedding provider: ${config.provider}`);
-    }
+    return new remote_1.RemoteEmbeddingProvider(config);
 }

package/dist/src/service/embedding/interface.d.ts

@@ -9,6 +9,11 @@ export interface EmbeddingProvider {
      * @param texts - Array of input texts
      */
     generateEmbeddings(texts: string[]): Promise<number[][]>;
+    /**
+     * Generate embedding for multimodal input (LAS specific)
+     * @param input - Multimodal input array
+     */
+    generateMultimodalEmbedding?(input: any[]): Promise<number[]>;
 }
 export interface EmbeddingConfig {
     provider: 'local' | 'remote' | 'openai' | 'las';

package/dist/src/service/embedding/remote.d.ts

@@ -12,4 +12,5 @@ export declare class RemoteEmbeddingProvider implements EmbeddingProvider {
     generateEmbeddings(texts: string[]): Promise<number[][]>;
     private generateOpenAICompatibleEmbeddings;
     private generateLasEmbeddings;
+    generateMultimodalEmbedding(input: any[]): Promise<number[]>;
 }

package/dist/src/service/embedding/remote.js

@@ -108,5 +108,36 @@ class RemoteEmbeddingProvider {
         });
         return Promise.all(requests);
     }
+    async generateMultimodalEmbedding(input) {
+        if (this.mode !== 'las-multimodal') {
+            throw new Error('generateMultimodalEmbedding requires LAS multimodal provider');
+        }
+        const endpoint = this.apiBase.endsWith('/api/v1/embeddings/multimodal')
+            ? this.apiBase
+            : `${this.apiBase}/api/v1/embeddings/multimodal`;
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify({
+                model: this.modelName,
+                encoding_format: this.encodingFormat,
+                ...(this.dimensions ? { dimensions: this.dimensions } : {}),
+                input
+            })
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`LAS embedding API error: ${response.status} ${error}`);
+        }
+        const data = await response.json();
+        const embedding = data?.data?.embedding;
+        if (!Array.isArray(embedding) || embedding.length === 0) {
+            throw new Error('Unexpected LAS embedding response format');
+        }
+        return embedding;
+    }
 }
 exports.RemoteEmbeddingProvider = RemoteEmbeddingProvider;

package/dist/src/service/metadata/interface.d.ts

@@ -7,6 +7,7 @@ export interface MetadataProvider {
     list(limit?: number, filter?: string): Promise<DocumentSchema[]>;
     delete(filter: string): Promise<void>;
     generateEmbedding(text: string): Promise<number[]>;
+    generateMultimodalEmbedding?(input: any[]): Promise<number[]>;
 }
 export interface MetadataConfig {
     type: 'local' | 'remote';

package/dist/src/service/metadata/local.d.ts

@@ -10,4 +10,5 @@ export declare class LocalMetadataProvider implements MetadataProvider {
     list(limit?: number, filter?: string): Promise<DocumentSchema[]>;
     delete(filter: string): Promise<void>;
     generateEmbedding(text: string): Promise<number[]>;
+    generateMultimodalEmbedding(input: any[]): Promise<number[]>;
 }

package/dist/src/service/metadata/local.js

@@ -45,5 +45,11 @@ class LocalMetadataProvider {
     async generateEmbedding(text) {
         return await this.embeddingProvider.generateEmbedding(text);
     }
+    async generateMultimodalEmbedding(input) {
+        if (this.embeddingProvider.generateMultimodalEmbedding) {
+            return await this.embeddingProvider.generateMultimodalEmbedding(input);
+        }
+        throw new Error('generateMultimodalEmbedding not supported by this embedding provider');
+    }
 }
 exports.LocalMetadataProvider = LocalMetadataProvider;

package/dist/src/utils/config.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getPluginConfig = getPluginConfig;
+const credentials_1 = require("./credentials");
 function getPluginConfig(ctx) {
+    const creds = (0, credentials_1.loadCredentials)();
     return ctx.config?.plugins?.entries?.['contextlake-openclaw']?.config || {
         metadata_storage: {
             type: 'local',
@@ -9,12 +11,19 @@ function getPluginConfig(ctx) {
             embedding: {
                 provider: 'las',
                 model_name: 'doubao-embedding-vision-250615',
-                api_key: process.env.LAS_API_KEY,
+                api_key: process.env.LAS_API_KEY || creds.LAS_API_KEY,
                 api_base: process.env.LAS_BASE_URL || 'https://operator.las.cn-beijing.volces.com',
                 dimensions: 2048,
                 encoding_format: 'float'
             }
         },
-        file_storage: { type: 'local', local_base_dir: require('path').join(require('os').homedir(), '.openclaw', 'contextlake', 'files') }
+        file_storage: {
+            type: 'local',
+            local_base_dir: require('path').join(require('os').homedir(), '.openclaw', 'contextlake', 'files'),
+            tos: {
+                access_key: process.env.VOLCENGINE_ACCESS_KEY || creds.VOLCENGINE_ACCESS_KEY,
+                secret_key: process.env.VOLCENGINE_SECRET_KEY || creds.VOLCENGINE_SECRET_KEY
+            }
+        }
     };
 }

package/dist/src/utils/credentials.d.ts

@@ -0,0 +1,8 @@
+export interface Credentials {
+    LAS_API_KEY?: string;
+    VOLCENGINE_ACCESS_KEY?: string;
+    VOLCENGINE_SECRET_KEY?: string;
+}
+export declare function loadCredentials(): Credentials;
+export declare function saveCredentials(creds: Credentials): void;
+export declare function promptForInput(promptText: string, defaultVal?: string): Promise<string>;

package/dist/src/utils/credentials.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCredentials = loadCredentials;
+exports.saveCredentials = saveCredentials;
+exports.promptForInput = promptForInput;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const readline = __importStar(require("readline"));
+const CONFIG_DIR = path.join(os.homedir(), '.openclaw', 'contextlake');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'credentials.json');
+function loadCredentials() {
+    if (fs.existsSync(CONFIG_FILE)) {
+        try {
+            const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (e) {
+            // ignore
+        }
+    }
+    return {};
+}
+function saveCredentials(creds) {
+    if (!fs.existsSync(CONFIG_DIR)) {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    const current = loadCredentials();
+    const updated = { ...current, ...creds };
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2), { mode: 0o600 });
+}
+async function promptForInput(promptText, defaultVal) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const displayPrompt = defaultVal ? `${promptText} [${defaultVal}]: ` : `${promptText}: `;
+    return new Promise((resolve) => {
+        rl.question(displayPrompt, (answer) => {
+            rl.close();
+            resolve(answer.trim() || defaultVal || '');
+        });
+    });
+}

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "contextlake-openclaw",
   "name": "ContextLake",
-  "version": "1.1.0",
+  "version": "1.0.3",
   "description": "A lightweight knowledge base plugin for OpenClaw using LanceDB and TOS, with data profiling support",
   "skills": ["./src/skills"],
   "configSchema": {

package/package.json

@@ -1,18 +1,14 @@
 {
   "name": "@byted-las/contextlake-openclaw",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "ContextLake OpenClaw Plugin for managing knowledge base",
   "main": "index.ts",
   "files": [
     "dist",
-    "bin",
     "index.ts",
     "src",
     "openclaw.plugin.json"
   ],
-  "bin": {
-    "contextlake-openclaw": "./bin/contextlake-openclaw.js"
-  },
   "openclaw": {
     "extensions": [
       "./dist/index.js"

package/src/client/lancedb.ts

@@ -87,7 +87,7 @@ export class ContextLakeLanceDBClient {
       return await fallbackQuery.toArray();
     }
 
-    const vector = await this.embeddingProvider.generateEmbedding(query);
+    const vector = await this.embeddingProvider.generateMultimodalEmbedding!([{ type: 'text', text: query }]);
     // @ts-ignore
     let search = table.vectorSearch(vector).limit(normalizedLimit);
     if (filter) {

package/src/commands/cli.ts

@@ -1,8 +1,9 @@
 // @ts-ignore
-import { ingestAssets } from '../lib/actions/ingest';
+import { ingestSource } from '../lib/actions/ingest';
 import { retrieveAssets } from '../lib/actions/retrieve';
 import { listAssets, deleteAssets } from '../lib/actions/manage';
 import { connectDataSource, ConnectParams } from '../lib/actions/profiler';
+import { loadCredentials, saveCredentials, promptForInput } from '../utils/credentials';
 import { ContextLakeConfig } from '../utils/config';
 
 function parseOptionalInt(value: any, fallback: number): number {
@@ -72,15 +73,11 @@ export function getCliCommands(pluginConfig: ContextLakeConfig, logger: any) {
             }
         },
 
-        ingestAction: async (files: any, options: any) => {
-            logger.info(`[${new Date().toISOString()}] [ContextLake] CLI ingest started`, { files, options });
+        ingestAction: async (datasource_name: string) => {
+            logger.info(`[${new Date().toISOString()}] [ContextLake] CLI ingest started`, { datasource_name });
             try {
-                const metadata = parseMetadata(options.metadata);
-                const result = await ingestAssets({
-                    files,
-                    metadata,
-                    chunkSize: parseOptionalInt(options.chunkSize, 500),
-                    overlap: parseOptionalInt(options.overlap, 50)
+                const result = await ingestSource({
+                    datasource_name
                 }, pluginConfig, logger);
                 // eslint-disable-next-line no-console
                 console.log(JSON.stringify(result, null, 2));
@@ -138,6 +135,35 @@ export function getCliCommands(pluginConfig: ContextLakeConfig, logger: any) {
                 console.error('Error:', e.message);
                 logger.error(`[${new Date().toISOString()}] [ContextLake] CLI delete failed`, { error: e.message, stack: e.stack });
             }
+        },
+
+        onboardAction: async () => {
+            logger.info(`[${new Date().toISOString()}] [ContextLake] CLI onboard started`);
+            try {
+                const currentCreds = loadCredentials();
+                // eslint-disable-next-line no-console
+                console.log('Welcome to ContextLake Onboarding!');
+                // eslint-disable-next-line no-console
+                console.log('Please provide your credentials below. Press enter to keep the current value.');
+                
+                const lasApiKey = await promptForInput('LAS_API_KEY', currentCreds.LAS_API_KEY);
+                const volcengineAccessKey = await promptForInput('VOLCENGINE_ACCESS_KEY', currentCreds.VOLCENGINE_ACCESS_KEY);
+                const volcengineSecretKey = await promptForInput('VOLCENGINE_SECRET_KEY', currentCreds.VOLCENGINE_SECRET_KEY);
+                
+                const newCreds = {
+                    LAS_API_KEY: lasApiKey,
+                    VOLCENGINE_ACCESS_KEY: volcengineAccessKey,
+                    VOLCENGINE_SECRET_KEY: volcengineSecretKey
+                };
+                
+                saveCredentials(newCreds);
+                // eslint-disable-next-line no-console
+                console.log('Credentials saved successfully!');
+                logger.info(`[${new Date().toISOString()}] [ContextLake] CLI onboard success`);
+            } catch (e: any) {
+                console.error('Error during onboarding:', e.message);
+                logger.error(`[${new Date().toISOString()}] [ContextLake] CLI onboard failed`, { error: e.message, stack: e.stack });
+            }
         }
     };
 }

package/src/commands/index.ts

@@ -27,6 +27,14 @@ export function registerAll(ctx: OpenClawPluginApi, logger: PluginLogger) {
         ctx.registerTool(tools.lasDataProfilerTool );
         logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.lasDataProfilerTool.name}`);
         
+        ctx.registerTool(tools.listDatasourceTool );
+        logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${tools.listDatasourceTool.name}`);
+
+        for (const lasTool of tools.lasTools) {
+            ctx.registerTool(lasTool);
+            logger.info(`[${new Date().toISOString()}] [ContextLake] Tool registered: ${lasTool.name}`);
+        }
+        
     } catch (error: any) {
         logger.error(`[${new Date().toISOString()}] [ContextLake] Error registering agent tools: ${error.message}${error.stack ? '\\n' + error.stack : ''}`);
         throw error;
@@ -56,11 +64,8 @@ export function registerAll(ctx: OpenClawPluginApi, logger: PluginLogger) {
                 .action(commands.connectAction);
 
             // 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')
+            contextlake.command('ingest <datasource_name>')
+                .description('Process and ingest all files from a connected data source into the knowledge base')
                 .action(commands.ingestAction);
 
             // Search
@@ -83,6 +88,11 @@ export function registerAll(ctx: OpenClawPluginApi, logger: PluginLogger) {
                 .option('--ids <ids...>', 'List of specific file IDs to delete')
                 .option('-f, --filter <string>', 'Filter string to match documents for deletion')
                 .action(commands.deleteAction);
+
+            // Onboard
+            contextlake.command('onboard')
+                .description('Configure credentials for ContextLake')
+                .action(commands.onboardAction);
                 
         }, { commands: ['contextlake'] });
         logger.info(`[${new Date().toISOString()}] [ContextLake] CLI commands registered`);
@@ -102,7 +112,7 @@ export function registerAll(ctx: OpenClawPluginApi, logger: PluginLogger) {
         
         ctx.registerCommand({
             name: 'contextlake-ingest',
-            description: 'Ingest files into the knowledge base (usage: /contextlake-ingest file1 file2)',
+            description: 'Process and ingest all files from a connected data source (usage: /contextlake-ingest <datasource_name>)',
             acceptsArgs: true,
             handler: slashCommands.ingestHandler
         });
@@ -127,6 +137,20 @@ export function registerAll(ctx: OpenClawPluginApi, logger: PluginLogger) {
             acceptsArgs: true,
             handler: slashCommands.deleteHandler
         });
+
+        ctx.registerCommand({
+            name: 'contextlake-profiler',
+            description: 'Connect to a data source and profile its structure (usage: /contextlake-profiler <datasource_name> <vendor> <bucket> <prefix>)',
+            acceptsArgs: true,
+            handler: slashCommands.profilerHandler
+        });
+
+        ctx.registerCommand({
+            name: 'contextlake-list-datasource',
+            description: 'List all connected and profiled data sources (usage: /contextlake-list-datasource)',
+            acceptsArgs: false,
+            handler: slashCommands.listDatasourceHandler
+        });
         
         logger.info(`[${new Date().toISOString()}] [ContextLake] Slash commands registered`);
     } catch (error: any) {