@byted-las/contextlake-openclaw 1.0.0 → 1.0.3

package/dist/src/lib/actions/ingest-source.js

@@ -0,0 +1,193 @@
+"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.ingestSource = ingestSource;
+const factory_1 = require("../../service/metadata/factory");
+const las_api_1 = require("./las-api");
+const lancedb = __importStar(require("@lancedb/lancedb"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+// @ts-ignore
+const uuid_1 = require("uuid");
+const BASE_DIR = path.join(os.homedir(), '.openclaw', 'contextlake', 'profiler');
+async function ingestSource(params, config, logger) {
+    if (logger) {
+        logger.info(`[ContextLake-Action] Calling ingestSource with params: ${JSON.stringify(params)}`);
+    }
+    else {
+        // eslint-disable-next-line no-console
+        console.log(`[ContextLake-Action] Calling ingestSource with params: ${JSON.stringify(params)}`);
+    }
+    const dsDir = path.join(BASE_DIR, params.datasource_name);
+    const dbPath = path.join(dsDir, 'catalog_db');
+    if (!fs.existsSync(dbPath)) {
+        throw new Error(`Data source database not found at ${dbPath}. Please run profiler connect first.`);
+    }
+    const metaConfig = config.metadata_storage || { type: 'local', lancedb_uri: './data/contextlake' };
+    const metadataProvider = (0, factory_1.createMetadataProvider)(metaConfig);
+    await metadataProvider.connect();
+    const lasClient = new las_api_1.LasApiClient(config, logger);
+    const results = [];
+    // Connect to the profiler LanceDB to read the file catalog
+    const profilerDb = await lancedb.connect(dbPath);
+    const tableNames = await profilerDb.tableNames();
+    if (!tableNames.includes('file_catalog')) {
+        throw new Error(`table 'file_catalog' not found in ${dbPath}`);
+    }
+    const catalogTable = await profilerDb.openTable('file_catalog');
+    const files = await catalogTable.query().toArray();
+    logger?.info(`[ContextLake-Action] Found ${files.length} files in catalog`);
+    // Simple chunking for text
+    const splitText = (text, chunkSize = 500, overlap = 50) => {
+        const chunks = [];
+        if (!text)
+            return chunks;
+        let i = 0;
+        while (i < text.length) {
+            chunks.push(text.slice(i, i + chunkSize));
+            i += chunkSize - overlap;
+        }
+        return chunks;
+    };
+    const processText = async (text, fileInfo) => {
+        const chunks = splitText(text);
+        const docs = [];
+        for (const chunk of chunks) {
+            const vector = await metadataProvider.generateMultimodalEmbedding([{ type: 'text', text: chunk }]);
+            docs.push({
+                id: (0, uuid_1.v4)(),
+                vector,
+                text: chunk,
+                source: fileInfo.key,
+                file_type: fileInfo.category,
+                storage_type: 'source',
+                url: fileInfo.url || `tos://${fileInfo.bucket}/${fileInfo.key}`,
+                metadata: JSON.stringify({ datasource: params.datasource_name }),
+                created_at: Date.now(),
+                binary_data: Buffer.from('')
+            });
+        }
+        return docs;
+    };
+    for (const file of files) {
+        try {
+            logger?.info(`[ContextLake-Action] Processing file: ${file.key}, type: ${file.media_type}`);
+            let docs = [];
+            const fileUrl = file.url || `tos://${file.bucket}/${file.key}`;
+            if (file.media_type === 'pdf') {
+                // PDF Parse
+                const result = await lasClient.submitAndPoll('las_pdf_parse_doubao', {
+                    url: fileUrl
+                });
+                const markdown = result.data?.markdown || '';
+                docs = await processText(markdown, file);
+            }
+            else if (file.media_type === 'image') {
+                // Multimodal Embedding directly
+                const vector = await metadataProvider.generateMultimodalEmbedding([
+                    { type: 'image_url', image_url: { url: fileUrl } },
+                    { type: 'text', text: 'This is an image from the dataset.' }
+                ]);
+                docs.push({
+                    id: (0, uuid_1.v4)(),
+                    vector,
+                    text: 'Image from dataset',
+                    source: file.key,
+                    file_type: 'image',
+                    storage_type: 'source',
+                    url: fileUrl,
+                    metadata: JSON.stringify({ datasource: params.datasource_name }),
+                    created_at: Date.now(),
+                    binary_data: Buffer.from('')
+                });
+            }
+            else if (file.media_type === 'audio') {
+                // ASR
+                const result = await lasClient.submitAndPoll('las_asr_pro', {
+                    audio: { url: fileUrl, format: file.key.split('.').pop() || 'wav' },
+                    request: { model_name: 'bigmodel' }
+                });
+                const text = result.data?.result?.text || '';
+                docs = await processText(text, file);
+            }
+            else if (file.media_type === 'video') {
+                // Video understanding -> text -> embedding
+                const result = await lasClient.submitAndPoll('las_long_video_understand', {
+                    video_url: fileUrl,
+                    query: "详细描述这个视频的内容",
+                    model_name: "doubao-seed-2-0-lite-260215"
+                });
+                // Assuming video output is a text description somewhere in the response. 
+                // Note: the exact structure depends on the API return, adjusting to generic text.
+                const text = JSON.stringify(result.data || '');
+                // Also need audio extract and ASR for video
+                // 1. Extract audio
+                // The output_path_template needs a unique path per video
+                const audioOutputPath = `tos://${file.bucket}/.tmp/audio/${(0, uuid_1.v4)()}.wav`;
+                await lasClient.process('las_audio_extract_and_split', {
+                    input_path: fileUrl,
+                    output_path_template: audioOutputPath,
+                    output_format: 'wav'
+                });
+                // 2. ASR on the extracted audio
+                // Wait briefly for object to be available if needed (often synchronous but tos takes a ms)
+                const asrResult = await lasClient.submitAndPoll('las_asr_pro', {
+                    audio: { url: audioOutputPath.replace('{index}.{output_file_ext}', '0.wav'), format: 'wav' },
+                    request: { model_name: 'bigmodel' }
+                });
+                const audioText = asrResult.data?.result?.text || '';
+                // Combine video text and audio text
+                const combinedText = `Video Description: ${text}\n\nAudio Transcription: ${audioText}`;
+                docs = await processText(combinedText, file);
+            }
+            else if (file.category === 'structured' || file.category === 'non-structured') {
+                // If we had a direct text content, we could process it here. 
+                // Assuming basic local download or similar is available, but for now we skip raw file reading from TOS in this demo script unless implemented.
+                // Fallback just logs
+                logger?.warn(`[ContextLake-Action] Skipping raw text/structured download for ${file.key} - implement TOS download if needed`);
+            }
+            if (docs.length > 0) {
+                await metadataProvider.addAssets(docs);
+                results.push({ file: file.key, status: 'success', chunks: docs.length });
+            }
+        }
+        catch (error) {
+            logger?.error(`[ContextLake-Action] Error processing ${file.key}: ${error.message}`);
+            results.push({ file: file.key, status: 'error', message: error.message });
+        }
+    }
+    return results;
+}

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

@@ -1,8 +1,15 @@
-interface IngestParams {
-    files: string[];
-    metadata?: Record<string, any>;
-    chunkSize?: number;
-    overlap?: number;
+import { ContextLakeConfig } from '../../utils/config';
+export interface IngestSourceParams {
+    datasource_name: string;
 }
-export declare function ingestAssets(params: IngestParams, config: any, logger?: any): Promise<any>;
-export {};
+export declare function ingestSource(params: IngestSourceParams, config: ContextLakeConfig, logger?: any): Promise<({
+    file: any;
+    status: string;
+    chunks: number;
+    message?: undefined;
+} | {
+    file: any;
+    status: string;
+    message: any;
+    chunks?: undefined;
+})[]>;

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

@@ -33,91 +33,161 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ingestAssets = ingestAssets;
-const factory_1 = require("../../service/storage/factory");
-const factory_2 = require("../../service/metadata/factory");
-const loader_1 = require("../../processor/loader");
+exports.ingestSource = ingestSource;
+const factory_1 = require("../../service/metadata/factory");
+const las_api_1 = require("./las-api");
+const lancedb = __importStar(require("@lancedb/lancedb"));
 const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
 // @ts-ignore
 const uuid_1 = require("uuid");
-async function ingestAssets(params, config, logger) {
+const BASE_DIR = path.join(os.homedir(), '.openclaw', 'contextlake', 'profiler');
+async function ingestSource(params, config, logger) {
     if (logger) {
-        logger.info(`[ContextLake-Action] Calling ingestAssets with params: ${JSON.stringify(params)}`);
+        logger.info(`[ContextLake-Action] Calling ingestSource with params: ${JSON.stringify(params)}`);
     }
     else {
         // eslint-disable-next-line no-console
-        console.log(`[ContextLake-Action] Calling ingestAssets with params: ${JSON.stringify(params)}`);
+        console.log(`[ContextLake-Action] Calling ingestSource with params: ${JSON.stringify(params)}`);
+    }
+    const dsDir = path.join(BASE_DIR, params.datasource_name);
+    const dbPath = path.join(dsDir, 'catalog_db');
+    if (!fs.existsSync(dbPath)) {
+        throw new Error(`Data source database not found at ${dbPath}. Please run profiler connect first.`);
     }
-    const storageConfig = config.file_storage || { type: 'local', local_base_dir: './data/files' };
     const metaConfig = config.metadata_storage || { type: 'local', lancedb_uri: './data/contextlake' };
-    const storageProvider = (0, factory_1.createStorageProvider)(storageConfig);
-    const metadataProvider = (0, factory_2.createMetadataProvider)(metaConfig);
+    const metadataProvider = (0, factory_1.createMetadataProvider)(metaConfig);
     await metadataProvider.connect();
-    const maxInlineSize = (config.storage_policy?.max_inline_size_kb || 1024) * 1024;
+    const lasClient = new las_api_1.LasApiClient(config, logger);
     const results = [];
-    for (const filePath of params.files) {
+    // Connect to the profiler LanceDB to read the file catalog
+    const profilerDb = await lancedb.connect(dbPath);
+    const tableNames = await profilerDb.tableNames();
+    if (!tableNames.includes('file_catalog')) {
+        throw new Error(`table 'file_catalog' not found in ${dbPath}`);
+    }
+    const catalogTable = await profilerDb.openTable('file_catalog');
+    const files = await catalogTable.query().toArray();
+    logger?.info(`[ContextLake-Action] Found ${files.length} files in catalog`);
+    // Simple chunking for text
+    const splitText = (text, chunkSize = 500, overlap = 50) => {
+        const chunks = [];
+        if (!text)
+            return chunks;
+        let i = 0;
+        while (i < text.length) {
+            chunks.push(text.slice(i, i + chunkSize));
+            i += chunkSize - overlap;
+        }
+        return chunks;
+    };
+    const processText = async (text, fileInfo) => {
+        const chunks = splitText(text);
+        const docs = [];
+        for (const chunk of chunks) {
+            const vector = await metadataProvider.generateMultimodalEmbedding([{ type: 'text', text: chunk }]);
+            docs.push({
+                id: (0, uuid_1.v4)(),
+                vector,
+                text: chunk,
+                source: fileInfo.key,
+                file_type: fileInfo.category,
+                storage_type: 'source',
+                url: fileInfo.url || `tos://${fileInfo.bucket}/${fileInfo.key}`,
+                metadata: JSON.stringify({ datasource: params.datasource_name }),
+                created_at: Date.now(),
+                binary_data: Buffer.from('')
+            });
+        }
+        return docs;
+    };
+    for (const file of files) {
         try {
-            const fileName = path.basename(filePath);
-            const { buffer, text, type } = await (0, loader_1.processFile)(filePath);
-            const createdAt = Date.now(); // Current timestamp
-            let fileUrl = '';
-            let storageType = '';
-            let binaryData = Buffer.alloc(0);
-            // Decide storage strategy
-            if (buffer.length <= maxInlineSize) {
-                binaryData = buffer;
-                fileUrl = `inline://${fileName}`; // Virtual URL for inline
-                storageType = 'inline';
-            }
-            else {
-                fileUrl = await storageProvider.uploadFile(fileName, buffer);
-                storageType = storageConfig.type;
+            logger?.info(`[ContextLake-Action] Processing file: ${file.key}, type: ${file.media_type}`);
+            let docs = [];
+            const fileUrl = file.url || `tos://${file.bucket}/${file.key}`;
+            if (file.media_type === 'pdf') {
+                // PDF Parse
+                const result = await lasClient.submitAndPoll('las_pdf_parse_doubao', {
+                    url: fileUrl
+                });
+                const markdown = result.data?.markdown || '';
+                docs = await processText(markdown, file);
             }
-            const chunks = (0, loader_1.splitText)(text, params.chunkSize || 500, params.overlap || 50);
-            const docs = [];
-            // If no text extracted (e.g. image), store one entry with empty text but with metadata/binary
-            if (chunks.length === 0) {
-                const vector = await metadataProvider.generateEmbedding(fileName); // Embed filename as fallback
+            else if (file.media_type === 'image') {
+                // Multimodal Embedding directly
+                const vector = await metadataProvider.generateMultimodalEmbedding([
+                    { type: 'image_url', image_url: { url: fileUrl } },
+                    { type: 'text', text: 'This is an image from the dataset.' }
+                ]);
                 docs.push({
                     id: (0, uuid_1.v4)(),
                     vector,
-                    text: '',
-                    source: fileName,
-                    file_type: type,
-                    storage_type: storageType,
+                    text: 'Image from dataset',
+                    source: file.key,
+                    file_type: 'image',
+                    storage_type: 'source',
                     url: fileUrl,
-                    metadata: JSON.stringify(params.metadata || {}),
-                    created_at: createdAt,
-                    binary_data: binaryData
+                    metadata: JSON.stringify({ datasource: params.datasource_name }),
+                    created_at: Date.now(),
+                    binary_data: Buffer.from('')
                 });
             }
-            else {
-                for (const chunk of chunks) {
-                    const vector = await metadataProvider.generateEmbedding(chunk);
-                    docs.push({
-                        id: (0, uuid_1.v4)(),
-                        vector,
-                        text: chunk,
-                        source: fileName,
-                        file_type: type,
-                        storage_type: storageType,
-                        url: fileUrl,
-                        metadata: JSON.stringify(params.metadata || {}),
-                        created_at: createdAt,
-                        binary_data: binaryData // Only attach to first chunk
-                    });
-                    // Clear binary data for subsequent chunks of the same file to avoid duplication
-                    binaryData = Buffer.alloc(0);
-                }
+            else if (file.media_type === 'audio') {
+                // ASR
+                const result = await lasClient.submitAndPoll('las_asr_pro', {
+                    audio: { url: fileUrl, format: file.key.split('.').pop() || 'wav' },
+                    request: { model_name: 'bigmodel' }
+                });
+                const text = result.data?.result?.text || '';
+                docs = await processText(text, file);
+            }
+            else if (file.media_type === 'video') {
+                // Video understanding -> text -> embedding
+                const result = await lasClient.submitAndPoll('las_long_video_understand', {
+                    video_url: fileUrl,
+                    query: "详细描述这个视频的内容",
+                    model_name: "doubao-seed-2-0-lite-260215"
+                });
+                // Assuming video output is a text description somewhere in the response. 
+                // Note: the exact structure depends on the API return, adjusting to generic text.
+                const text = JSON.stringify(result.data || '');
+                // Also need audio extract and ASR for video
+                // 1. Extract audio
+                // The output_path_template needs a unique path per video
+                const audioOutputPath = `tos://${file.bucket}/.tmp/audio/${(0, uuid_1.v4)()}.wav`;
+                await lasClient.process('las_audio_extract_and_split', {
+                    input_path: fileUrl,
+                    output_path_template: audioOutputPath,
+                    output_format: 'wav'
+                });
+                // 2. ASR on the extracted audio
+                // Wait briefly for object to be available if needed (often synchronous but tos takes a ms)
+                const asrResult = await lasClient.submitAndPoll('las_asr_pro', {
+                    audio: { url: audioOutputPath.replace('{index}.{output_file_ext}', '0.wav'), format: 'wav' },
+                    request: { model_name: 'bigmodel' }
+                });
+                const audioText = asrResult.data?.result?.text || '';
+                // Combine video text and audio text
+                const combinedText = `Video Description: ${text}\n\nAudio Transcription: ${audioText}`;
+                docs = await processText(combinedText, file);
+            }
+            else if (file.category === 'structured' || file.category === 'non-structured') {
+                // If we had a direct text content, we could process it here. 
+                // Assuming basic local download or similar is available, but for now we skip raw file reading from TOS in this demo script unless implemented.
+                // Fallback just logs
+                logger?.warn(`[ContextLake-Action] Skipping raw text/structured download for ${file.key} - implement TOS download if needed`);
+            }
+            if (docs.length > 0) {
+                await metadataProvider.addAssets(docs);
+                results.push({ file: file.key, status: 'success', chunks: docs.length });
             }
-            await metadataProvider.addAssets(docs);
-            results.push({ file: fileName, status: 'success', chunks: docs.length });
         }
         catch (error) {
-            // @ts-ignore
-            results.push({ file: filePath, status: 'error', message: error.message });
+            logger?.error(`[ContextLake-Action] Error processing ${file.key}: ${error.message}`);
+            results.push({ file: file.key, status: 'error', message: error.message });
         }
     }
-    // Ensure plain JSON serialization
-    return JSON.parse(JSON.stringify(results));
+    return results;
 }

package/dist/src/lib/actions/las-api.d.ts

@@ -0,0 +1,13 @@
+import { ContextLakeConfig } from '../../utils/config';
+export declare class LasApiClient {
+    private endpoint;
+    private apiKey;
+    private logger;
+    constructor(config: ContextLakeConfig, logger: any);
+    private request;
+    process(operatorId: string, data: any, version?: string): Promise<any>;
+    submit(operatorId: string, data: any, version?: string): Promise<any>;
+    poll(operatorId: string, taskId: string, version?: string): Promise<any>;
+    submitAndPoll(operatorId: string, data: any, version?: string, pollIntervalMs?: number, maxRetries?: number): Promise<any>;
+    multimodalEmbedding(model: string, input: any[], encodingFormat?: string, dimensions?: number, instructions?: string, sparseEmbedding?: any): Promise<any>;
+}

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LasApiClient = void 0;
+class LasApiClient {
+    endpoint;
+    apiKey;
+    logger;
+    constructor(config, logger) {
+        this.logger = logger;
+        this.apiKey = config.metadata_storage?.embedding?.api_key || process.env.LAS_API_KEY || '';
+        this.endpoint = config.metadata_storage?.embedding?.api_base || process.env.LAS_BASE_URL || 'https://operator.las.cn-beijing.volces.com';
+        // Remove trailing slash
+        if (this.endpoint.endsWith('/')) {
+            this.endpoint = this.endpoint.slice(0, -1);
+        }
+    }
+    async request(path, body) {
+        if (!this.apiKey) {
+            throw new Error('LAS_API_KEY is not configured. Please set it in config or environment variables.');
+        }
+        const url = `${this.endpoint}${path}`;
+        this.logger.debug(`[LasApiClient] Requesting ${url}`, { body: JSON.stringify(body) });
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${this.apiKey}`
+            },
+            body: JSON.stringify(body)
+        });
+        if (!response.ok) {
+            let errorText = '';
+            try {
+                errorText = await response.text();
+            }
+            catch (e) { }
+            throw new Error(`LAS API Error: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+        const result = await response.json();
+        return result;
+    }
+    async process(operatorId, data, version = 'v1') {
+        const result = await this.request('/api/v1/process', {
+            operator_id: operatorId,
+            operator_version: version,
+            data
+        });
+        return result;
+    }
+    async submit(operatorId, data, version = 'v1') {
+        const result = await this.request('/api/v1/submit', {
+            operator_id: operatorId,
+            operator_version: version,
+            data
+        });
+        return result;
+    }
+    async poll(operatorId, taskId, version = 'v1') {
+        const result = await this.request('/api/v1/poll', {
+            operator_id: operatorId,
+            operator_version: version,
+            task_id: taskId
+        });
+        return result;
+    }
+    async submitAndPoll(operatorId, data, version = 'v1', pollIntervalMs = 3000, maxRetries = 200) {
+        const submitResult = await this.submit(operatorId, data, version);
+        if (!submitResult?.metadata?.task_id) {
+            throw new Error(`Failed to submit task for ${operatorId}. Response: ${JSON.stringify(submitResult)}`);
+        }
+        const taskId = submitResult.metadata.task_id;
+        this.logger.info(`[LasApiClient] Task submitted: ${taskId} for ${operatorId}`);
+        let retries = 0;
+        while (retries < maxRetries) {
+            await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
+            const pollResult = await this.poll(operatorId, taskId, version);
+            const status = pollResult?.metadata?.task_status;
+            this.logger.debug(`[LasApiClient] Task ${taskId} status: ${status}`);
+            if (status === 'COMPLETED') {
+                return pollResult;
+            }
+            else if (status === 'FAILED' || status === 'TIMEOUT') {
+                const errorMsg = pollResult?.metadata?.error_msg || 'Unknown error';
+                throw new Error(`Task ${taskId} failed with status: ${status}. Message: ${errorMsg}`);
+            }
+            retries++;
+        }
+        throw new Error(`Task ${taskId} timed out after ${maxRetries} polling attempts.`);
+    }
+    async multimodalEmbedding(model, input, encodingFormat = 'float', dimensions, instructions, sparseEmbedding) {
+        const body = {
+            model,
+            input,
+            encoding_format: encodingFormat
+        };
+        if (dimensions)
+            body.dimensions = dimensions;
+        if (instructions)
+            body.instructions = instructions;
+        if (sparseEmbedding)
+            body.sparse_embedding = sparseEmbedding;
+        return await this.request('/api/v1/embeddings/multimodal', body);
+    }
+}
+exports.LasApiClient = LasApiClient;

package/dist/src/lib/actions/las-tools.d.ts

@@ -0,0 +1,3 @@
+import { ContextLakeConfig } from '../../utils/config';
+import type { AnyAgentTool } from 'openclaw/plugin-sdk';
+export declare function getLasTools(pluginConfig: ContextLakeConfig, logger: any): AnyAgentTool[];