@byted-las/contextlake-openclaw 1.0.0 → 1.0.3

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

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLasTools = getLasTools;
+const las_api_1 = require("./las-api");
+function getLasTools(pluginConfig, logger) {
+    const apiClient = new las_api_1.LasApiClient(pluginConfig, logger);
+    const callApi = async (method, args) => {
+        try {
+            // @ts-ignore
+            return await apiClient[method](...args);
+        }
+        catch (error) {
+            logger.error(`[LasTools] API ${method} failed`, { error: error.message });
+            return { error: error.message };
+        }
+    };
+    return [
+        {
+            name: 'las_image_resample',
+            label: 'LAS Image Resample',
+            description: `Resample/Resize an image and save it to TOS. 
+Parameters in data:
+- image_src_type (string, default: "image_url"): "image_url" or "image_tos"
+- image (string, required): URL or tos:// path
+- tos_dir (string, required): tos:// output directory
+- image_suffix (string): ".jpg" or ".png"
+- target_size (array of integers): e.g. [1024, 1024]
+- target_dpi (array of integers): e.g. [72, 72]
+- method (string): "nearest", "bilinear", "bicubic", "lanczos"`,
+            parameters: {
+                type: 'object',
+                properties: { data: { type: 'object', additionalProperties: true } },
+                required: ['data']
+            },
+            async execute(toolCallId, params) {
+                return await callApi('process', ['las_image_resample', params.data]);
+            }
+        },
+        {
+            name: 'las_audio_extract_and_split',
+            label: 'LAS Audio Extract and Split',
+            description: `Extract audio from video and split it into chunks.
+Parameters in data:
+- input_path (string, required): tos:// video path
+- output_path_template (string, required): e.g. tos://bucket/{index}.{output_file_ext}
+- split_duration (number): duration in seconds, default 30.0
+- output_format (string): "wav", "mp3", "flac"
+- timeout (integer)
+- extra_params (array of string): ffmpeg params`,
+            parameters: {
+                type: 'object',
+                properties: { data: { type: 'object', additionalProperties: true } },
+                required: ['data']
+            },
+            async execute(toolCallId, params) {
+                return await callApi('process', ['las_audio_extract_and_split', params.data]);
+            }
+        },
+        {
+            name: 'las_audio_convert',
+            label: 'LAS Audio Convert',
+            description: `Convert audio format.
+Parameters in data:
+- input_path (string, required): tos:// audio path
+- output_path (string, required): tos:// output path
+- output_format (string): "wav", "mp3", "flac"
+- extra_params (array of string): ffmpeg params`,
+            parameters: {
+                type: 'object',
+                properties: { data: { type: 'object', additionalProperties: true } },
+                required: ['data']
+            },
+            async execute(toolCallId, params) {
+                return await callApi('process', ['las_audio_convert', params.data]);
+            }
+        },
+        {
+            name: 'las_asr_pro',
+            label: 'LAS ASR Pro (Speech Recognition)',
+            description: `Perform automatic speech recognition (ASR).
+Parameters in data:
+- resource: "bigasr" or "seedasr"
+- audio (object, required): { url: string, language: string, format: string }
+- request (object, required): { model_name: "bigmodel", ... }
+- user (object): { uid: string }`,
+            parameters: {
+                type: 'object',
+                properties: { data: { type: 'object', additionalProperties: true } },
+                required: ['data']
+            },
+            async execute(toolCallId, params) {
+                return await callApi('submitAndPoll', ['las_asr_pro', params.data]);
+            }
+        },
+        {
+            name: 'las_seed_2_0',
+            label: 'LAS Seed 2.0 (Audio)',
+            description: `ASR with Seed 2.0.
+Parameters in data:
+- audio (object, required): { url, format, language }
+- request (object, required): { model_name: "seedasr", ... }`,
+            parameters: {
+                type: 'object',
+                properties: { data: { type: 'object', additionalProperties: true } },
+                required: ['data']
+            },
+            async execute(toolCallId, params) {
+                return await callApi('submitAndPoll', ['las_seed_2_0', params.data]);
+            }
+        },
+        {
+            name: 'las_bare_image_text_embedding',
+            label: 'LAS Multimodal Embedding',
+            description: `Multimodal Embedding (image and text).
+Parameters:
+- model (string, required): "doubao-embedding-vision-250615"
+- input (array of objects, required): [ { type: "image_url", image_url: { url: "..." } }, { type: "text", text: "..." } ]
+- encoding_format (string): "float", "base64"
+- dimensions (integer): 1024 or 2048`,
+            parameters: {
+                type: 'object',
+                properties: {
+                    model: { type: 'string', default: 'doubao-embedding-vision-250615' },
+                    input: { type: 'array', items: { type: 'object' } },
+                    encoding_format: { type: 'string', default: 'float' },
+                    dimensions: { type: 'integer' }
+                },
+                required: ['model', 'input']
+            },
+            async execute(toolCallId, params) {
+                return await callApi('multimodalEmbedding', [
+                    params.model,
+                    params.input,
+                    params.encoding_format,
+                    params.dimensions
+                ]);
+            }
+        },
+        {
+            name: 'las_long_video_understand',
+            label: 'LAS Long Video Understand',
+            description: `Long Video Understanding.
+Parameters in data:
+- video_url (string, required)
+- query (string, required)
+- model_name (string): default "doubao-seed-2-0-lite-260215"
+- ...other params like fps, target_tokens_per_clip`,
+            parameters: {
+                type: 'object',
+                properties: { data: { type: 'object', additionalProperties: true } },
+                required: ['data']
+            },
+            async execute(toolCallId, params) {
+                return await callApi('submitAndPoll', ['las_long_video_understand', params.data]);
+            }
+        },
+        {
+            name: 'las_pdf_parse_doubao',
+            label: 'LAS PDF Parse Doubao',
+            description: `Parse PDF documents to Markdown.
+Parameters in data:
+- url (string, required): PDF URL or tos://
+- start_page (integer): default 1
+- num_pages (integer): default to end
+- parse_mode (string): "normal" or "detail"`,
+            parameters: {
+                type: 'object',
+                properties: { data: { type: 'object', additionalProperties: true } },
+                required: ['data']
+            },
+            async execute(toolCallId, params) {
+                return await callApi('submitAndPoll', ['las_pdf_parse_doubao', params.data]);
+            }
+        },
+        {
+            name: 'las_video_resize',
+            label: 'LAS Video Resize',
+            description: `Resize video.
+Parameters in data:
+- video_url (string, required): URL or tos://
+- target_width (integer)
+- target_height (integer)
+- output_dir (string, required): tos://`,
+            parameters: {
+                type: 'object',
+                properties: { data: { type: 'object', additionalProperties: true } },
+                required: ['data']
+            },
+            async execute(toolCallId, params) {
+                return await callApi('submitAndPoll', ['las_video_resize', params.data]);
+            }
+        }
+    ];
+}

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

@@ -0,0 +1,64 @@
+import { ContextLakeConfig } from '../../utils/config';
+export declare function lasPdfParseDoubao(params: {
+    url: string;
+    start_page?: number;
+    num_pages?: number;
+    parse_mode?: string;
+}, config?: ContextLakeConfig): Promise<any>;
+export declare function lasLongVideoUnderstand(params: {
+    video_url: string;
+    prompt: string;
+    system_prompt?: string;
+    return_chunk_text?: boolean;
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+}, config?: ContextLakeConfig): Promise<any>;
+export declare function lasBareImageTextEmbedding(params: {
+    input: Array<{
+        type: string;
+        text?: string;
+        image_url?: string;
+    }>;
+    encoding_format?: string;
+}, config?: ContextLakeConfig): Promise<any>;
+export declare function lasSeed20(params: {
+    model: string;
+    messages: Array<any>;
+    stream?: boolean;
+    max_tokens?: number;
+    temperature?: number;
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    tools?: Array<any>;
+    tool_choice?: any;
+    user?: string;
+    logprobs?: boolean;
+    top_logprobs?: number;
+}, config?: ContextLakeConfig): Promise<any>;
+export declare function lasAsrPro(params: {
+    url?: string;
+    format?: string;
+    language?: string;
+    resource?: string;
+    use_itn?: boolean;
+    use_sn?: boolean;
+    enable_alignment?: boolean;
+    channel_id?: number;
+    use_word_info?: boolean;
+    text_format?: number;
+    enable_semantic_sentence_detection?: boolean;
+    boost_words?: Array<{
+        word: string;
+        weight: number;
+    }>;
+}, config?: ContextLakeConfig): Promise<any>;
+export declare function lasAudioExtractAndSplit(params: {
+    input_path: string;
+    output_path_template: string;
+    split_duration?: number;
+    output_format?: string;
+    timeout?: number;
+    extra_params?: string[];
+}, config?: ContextLakeConfig): Promise<any>;

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/manage.d.ts

@@ -1,3 +1,4 @@
+import { ContextLakeConfig } from '../../utils/config';
 interface ListParams {
     limit?: number;
 }
@@ -5,8 +6,8 @@ interface DeleteParams {
     file_ids?: string[];
     filter?: string;
 }
-export declare function listAssets(params: ListParams, config: any, logger?: any): Promise<any>;
-export declare function deleteAssets(params: DeleteParams, config: any, logger?: any): Promise<{
+export declare function listAssets(params: ListParams, config: ContextLakeConfig, logger?: any): Promise<any>;
+export declare function deleteAssets(params: DeleteParams, config: ContextLakeConfig, logger?: any): Promise<{
     status: string;
     message: string;
     deleted_count: number;

package/dist/src/{skills/las-data-profiler/index.d.ts → lib/actions/profiler.d.ts}

@@ -9,7 +9,7 @@ export interface ConnectParams {
     prefix: string;
     sample_rows?: number;
 }
-interface ConnectResult {
+export interface ConnectResult {
     status: 'success' | 'error';
     datasource_name: string;
     db_path: string;
@@ -23,4 +23,6 @@ interface ConnectResult {
     error?: string;
 }
 export declare function connectDataSource(params: ConnectParams, _ctx?: any): Promise<ConnectResult>;
-export {};
+export declare function listDataSources(_ctx?: any): Promise<{
+    datasources: string[];
+}>;

package/dist/src/{skills/las-data-profiler/index.js → 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
@@ -109,8 +110,8 @@ function ensurePythonDeps() {
  * Get the path to the bundled Python script.
  */
 function getScriptPath() {
-    // The Python script is co-located with this module
-    return path.join(__dirname, 's3_catalog.py');
+    // The Python script is located in the scripts directory
+    return path.join(__dirname, '../scripts', 's3_catalog.py');
 }
 // ---------------------------------------------------------------------------
 // Main Entry
@@ -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.d.ts

@@ -1,8 +1,9 @@
+import { ContextLakeConfig } from '../../utils/config';
 interface RetrieveParams {
     query: string;
     top_k?: number;
     filter?: string;
     include_binary?: boolean;
 }
-export declare function retrieveAssets(params: RetrieveParams, config: any, logger?: any): Promise<any[]>;
+export declare function retrieveAssets(params: RetrieveParams, config: ContextLakeConfig, logger?: any): Promise<any[]>;
 export {};

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

@@ -19,17 +19,11 @@ async function retrieveAssets(params, config, logger) {
     }
     await metadataProvider.connect();
     const results = await metadataProvider.search(params.query, params.top_k || 5, params.filter);
-    // Post-process to handle binary data retrieval if requested
     if (params.include_binary) {
         const enrichedResults = await Promise.all(results.map(async (doc) => {
-            // Remove raw binary_data buffer to avoid clone errors in postMessage
-            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 inline binary data (Base64)
                     return {
                         ...rest,
                         binary_content: binary_data ? binary_data.toString('base64') : null
@@ -37,7 +31,6 @@ async function retrieveAssets(params, config, logger) {
                 }
                 else if (rest.storage_type === 'local' || rest.storage_type === 'tos') {
                     if (storageProvider) {
-                        // Download from storage provider
                         const buffer = await storageProvider.downloadFile(rest.url);
                         return {
                             ...rest,
@@ -56,17 +49,8 @@ async function retrieveAssets(params, config, logger) {
         }));
         return enrichedResults;
     }
-    // Remove binary_data from default response to keep it light and serializable
     return results.map((doc) => {
-        const { binary_data, ...rest } = doc;
-        // Ensure all fields are standard serializable types (remove complex objects/buffers)
-        if (rest.vector) {
-            // Keep vector as standard array of numbers if it exists, but some clients might choke on large arrays.
-            // Usually vector is fine, but LanceDB might return custom objects like Float32Array which fail structuredClone in postMessage
-            rest.vector = Array.from(rest.vector);
-        }
-        // LanceDB records might be Proxy objects or contain non-clonable getters.
-        // We stringify and parse to get a clean, plain Javascript Object.
+        const { binary_data, vector, ...rest } = doc;
         const safeDoc = JSON.parse(JSON.stringify(rest));
         return safeDoc;
     });

package/{src/skills/las-data-profiler → 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/processor/loader.js

@@ -72,12 +72,19 @@ function splitText(text, chunkSize = 500, overlap = 50) {
     const chunks = [];
     if (!text)
         return chunks;
+    const safeChunkSize = Number.isFinite(chunkSize) ? Math.max(1, Math.floor(chunkSize)) : 500;
+    const safeOverlapRaw = Number.isFinite(overlap) ? Math.max(0, Math.floor(overlap)) : 50;
+    const safeOverlap = Math.min(safeOverlapRaw, safeChunkSize - 1);
+    const step = Math.max(1, safeChunkSize - safeOverlap);
     let start = 0;
     while (start < text.length) {
-        const end = Math.min(start + chunkSize, text.length);
+        const end = Math.min(start + safeChunkSize, text.length);
         const chunk = text.slice(start, end);
+        if (!chunk) {
+            break;
+        }
         chunks.push(chunk);
-        start += chunkSize - overlap;
+        start += step;
     }
     return chunks;
 }

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') {
-        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,10 +9,17 @@ 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';
+    provider: 'local' | 'remote' | 'openai' | 'las';
     model_name: string;
     api_key?: string;
     api_base?: string;
+    dimensions?: number;
+    encoding_format?: 'float' | 'base64';
 }

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalEmbeddingProvider = exports.setNodeLlamaCppImporter = void 0;
 // import type { Llama, LlamaEmbeddingContext, LlamaModel } from 'node-llama-cpp';
-const DEFAULT_LOCAL_MODEL = "hf:CompendiumLabs/bge-small-zh-v1.5-gguf/bge-small-zh-v1.5-f16.gguf";
+const DEFAULT_LOCAL_MODEL = 'hf:CompendiumLabs/bge-small-zh-v1.5-gguf/bge-small-zh-v1.5-f16.gguf';
 let nodeLlamaImportPromise = null;
 const setNodeLlamaCppImporter = (importer) => {
     nodeLlamaImportPromise = importer();
@@ -10,7 +10,7 @@ const setNodeLlamaCppImporter = (importer) => {
 exports.setNodeLlamaCppImporter = setNodeLlamaCppImporter;
 const importNodeLlamaCpp = async () => {
     if (!nodeLlamaImportPromise) {
-        nodeLlamaImportPromise = import("node-llama-cpp");
+        nodeLlamaImportPromise = import('node-llama-cpp');
     }
     return nodeLlamaImportPromise;
 };
@@ -33,7 +33,13 @@ class LocalEmbeddingProvider {
         if (this.initPromise) {
             return this.initPromise;
         }
-        this.initPromise = this.doInitialize();
+        this.initPromise = this.doInitialize().catch((err) => {
+            this.initPromise = null;
+            this.context = null;
+            this.model = null;
+            this.llama = null;
+            throw err;
+        });
         return this.initPromise;
     }
     async doInitialize() {
@@ -58,15 +64,15 @@ class LocalEmbeddingProvider {
         }
     }
     async generateEmbedding(text) {
+        if (!text || !text.trim()) {
+            throw new Error('Embedding input text must be a non-empty string');
+        }
         await this.ensureInitialized();
         const embedding = await this.context.getEmbeddingFor(text);
         const vector = embedding.vector; // TypedArray
         // Optimized normalization loop
         let sumSq = 0;
         const len = vector.length;
-        // First pass: Calculate magnitude and sanitize (implicitly handled by JS numbers usually, but keeping finite check if needed)
-        // For performance, we assume node-llama-cpp returns valid floats. 
-        // If strict sanitization is needed, it can be combined.
         for (let i = 0; i < len; i++) {
             const val = vector[i];
             if (Number.isFinite(val)) {
@@ -85,19 +91,16 @@ class LocalEmbeddingProvider {
             }
         }
         else {
-            // Zero vector case
             for (let i = 0; i < len; i++) {
-                result[i] = vector[i]; // or 0
+                result[i] = vector[i];
             }
         }
         return result;
     }
-    // Optimized batch processing for local embedding
     async generateEmbeddings(texts) {
-        await this.ensureInitialized();
-        // node-llama-cpp's createEmbeddingContext might not support batch directly yet depending on version,
-        // but we can at least optimize the loop.
-        // If newer version supports batch, we should use it. For now, we parallelize with limit.
+        if (!Array.isArray(texts)) {
+            throw new Error('Embedding input must be an array of strings');
+        }
         return Promise.all(texts.map(text => this.generateEmbedding(text)));
     }
 }

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

@@ -3,7 +3,14 @@ export declare class RemoteEmbeddingProvider implements EmbeddingProvider {
     private apiKey;
     private modelName;
     private apiBase;
+    private dimensions?;
+    private encodingFormat;
+    private mode;
     constructor(config: EmbeddingConfig);
+    private detectMode;
     generateEmbedding(text: string): Promise<number[]>;
     generateEmbeddings(texts: string[]): Promise<number[][]>;
+    private generateOpenAICompatibleEmbeddings;
+    private generateLasEmbeddings;
+    generateMultimodalEmbedding(input: any[]): Promise<number[]>;
 }