@byted-las/contextlake-openclaw 1.0.0 → 1.0.3

package/src/service/embedding/remote.ts

@@ -1,45 +1,165 @@
 import { EmbeddingProvider, EmbeddingConfig } from './interface';
 
+type RemoteApiMode = 'openai-compatible' | 'las-multimodal';
+
 export class RemoteEmbeddingProvider implements EmbeddingProvider {
   private apiKey: string;
   private modelName: string;
   private apiBase: string;
+  private dimensions?: number;
+  private encodingFormat: 'float' | 'base64';
+  private mode: RemoteApiMode;
 
   constructor(config: EmbeddingConfig) {
-    this.apiKey = config.api_key || '';
+    if (!config.api_key) {
+      throw new Error('Remote embedding API key is required');
+    }
+
+    this.apiKey = config.api_key;
     this.modelName = config.model_name;
-    this.apiBase = config.api_base || 'https://api.openai.com/v1';
+    this.apiBase = (config.api_base || 'https://api.openai.com/v1').replace(/\/$/, '');
+    this.dimensions = config.dimensions;
+    this.encodingFormat = config.encoding_format || 'float';
+    this.mode = this.detectMode(this.apiBase, config.provider);
+  }
+
+  private detectMode(apiBase: string, provider: EmbeddingConfig['provider']): RemoteApiMode {
+    if (provider === 'las' || apiBase.includes('/api/v1/embeddings/multimodal') || apiBase.includes('operator.las')) {
+      return 'las-multimodal';
+    }
+    return 'openai-compatible';
   }
 
   async generateEmbedding(text: string): Promise<number[]> {
     const embeddings = await this.generateEmbeddings([text]);
+    if (!embeddings.length) {
+      throw new Error('No embedding returned for input text');
+    }
     return embeddings[0];
   }
 
-  // Optimized batch embedding generation
   async generateEmbeddings(texts: string[]): Promise<number[][]> {
+    if (!Array.isArray(texts) || texts.length === 0) {
+      return [];
+    }
+
+    const sanitizedTexts = texts.map((text) => {
+      if (typeof text !== 'string' || !text.trim()) {
+        throw new Error('Embedding input text must be a non-empty string');
+      }
+      return text;
+    });
+
+    if (this.mode === 'las-multimodal') {
+      return this.generateLasEmbeddings(sanitizedTexts);
+    }
+
+    return this.generateOpenAICompatibleEmbeddings(sanitizedTexts);
+  }
+
+  private async generateOpenAICompatibleEmbeddings(texts: string[]): Promise<number[][]> {
     const response = await fetch(`${this.apiBase}/embeddings`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        input: texts,
+        model: this.modelName,
+        ...(this.dimensions ? { dimensions: this.dimensions } : {})
+      })
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Remote API error: ${response.status} ${error}`);
+    }
+
+    const data = await response.json();
+    if (data.data && Array.isArray(data.data) && data.data.length > 0) {
+      return data.data
+        .sort((a: any, b: any) => a.index - b.index)
+        .map((item: any) => item.embedding);
+    }
+
+    throw new Error('Unexpected OpenAI-compatible embedding response format');
+  }
+
+  private async generateLasEmbeddings(texts: string[]): Promise<number[][]> {
+    const endpoint = this.apiBase.endsWith('/api/v1/embeddings/multimodal')
+      ? this.apiBase
+      : `${this.apiBase}/api/v1/embeddings/multimodal`;
+
+    const requests = texts.map(async (text) => {
+      const response = await fetch(endpoint, {
         method: 'POST',
         headers: {
-            'Content-Type': 'application/json',
-            'Authorization': `Bearer ${this.apiKey}`
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.apiKey}`
         },
         body: JSON.stringify({
-            input: texts,
-            model: this.modelName
+          model: this.modelName,
+          encoding_format: this.encodingFormat,
+          ...(this.dimensions ? { dimensions: this.dimensions } : {}),
+          input: [
+            {
+              type: 'text',
+              text
+            }
+          ]
         })
+      });
+
+      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;
+    });
+
+    return Promise.all(requests);
+  }
+
+  async generateMultimodalEmbedding(input: any[]): Promise<number[]> {
+    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(`Remote API error: ${response.status} ${error}`);
+      const error = await response.text();
+      throw new Error(`LAS embedding API error: ${response.status} ${error}`);
     }
 
     const data = await response.json();
-    if (data.data && Array.isArray(data.data) && data.data.length > 0) {
-        // Ensure order matches input
-        return data.data.sort((a: any, b: any) => a.index - b.index).map((item: any) => item.embedding);
+    const embedding = data?.data?.embedding;
+    if (!Array.isArray(embedding) || embedding.length === 0) {
+      throw new Error('Unexpected LAS embedding response format');
     }
-    throw new Error('Unexpected API response format');
+    return embedding;
   }
 }

package/src/service/metadata/interface.ts

@@ -8,6 +8,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 {

package/src/service/metadata/local.ts

@@ -57,4 +57,11 @@ export class LocalMetadataProvider implements MetadataProvider {
   async generateEmbedding(text: string): Promise<number[]> {
     return await this.embeddingProvider.generateEmbedding(text);
   }
+
+  async generateMultimodalEmbedding(input: any[]): Promise<number[]> {
+    if (this.embeddingProvider.generateMultimodalEmbedding) {
+      return await this.embeddingProvider.generateMultimodalEmbedding(input);
+    }
+    throw new Error('generateMultimodalEmbedding not supported by this embedding provider');
+  }
 }

package/src/service/storage/factory.ts

@@ -1,6 +1,6 @@
 import { StorageProvider, StorageConfig } from './interface';
 import { LocalStorageProvider } from './local';
-import { ContextLakeTosClient } from '../../client/tos';
+import { ContextLakeTosClient, TosConfig } from '../../client/tos';
 
 export function createStorageProvider(config: StorageConfig): StorageProvider {
   if (config.type === 'local') {
@@ -9,7 +9,7 @@ export function createStorageProvider(config: StorageConfig): StorageProvider {
     if (!config.tos || !config.tos.region || !config.tos.path) {
         throw new Error('Missing TOS configuration: region and path required');
     }
-    return new ContextLakeTosClient(config.tos as any);
+    return new ContextLakeTosClient(config.tos as TosConfig);
   } else {
     throw new Error(`Unsupported storage type: ${config.type}`);
   }

package/src/utils/config.ts

@@ -1,13 +1,66 @@
-export function getPluginConfig(ctx: any) {
-    return ctx.config?.plugins?.entries?.['contextlake-openclaw']?.config || {
-        metadata_storage: { 
-            type: 'local', 
+import { loadCredentials } from './credentials';
+
+export interface EmbeddingConfig {
+    provider: string;
+    model_name: string;
+    api_key?: string;
+    api_base?: string;
+    dimensions?: number;
+    encoding_format?: string;
+}
+
+export interface MetadataStorageConfig {
+    type: 'local' | 'remote';
+    lancedb_uri?: string;
+    embedding?: EmbeddingConfig;
+}
+
+export interface FileStorageConfig {
+    type: 'local' | 'tos';
+    local_base_dir?: string;
+    tos?: {
+        access_key?: string;
+        secret_key?: string;
+        region?: string;
+        path?: string;
+        endpoint?: string;
+        sts_token?: string;
+    };
+}
+
+export interface StoragePolicyConfig {
+    max_inline_size_kb?: number;
+}
+
+export interface ContextLakeConfig {
+    metadata_storage?: MetadataStorageConfig;
+    file_storage?: FileStorageConfig;
+    storage_policy?: StoragePolicyConfig;
+}
+
+export function getPluginConfig(ctx: any): ContextLakeConfig {
+    const creds = loadCredentials();
+    
+    return (ctx.config?.plugins?.entries?.['contextlake-openclaw']?.config as ContextLakeConfig) || {
+        metadata_storage: {
+            type: 'local',
             lancedb_uri: require('path').join(require('os').homedir(), '.openclaw', 'contextlake', 'data'),
             embedding: {
-                provider: 'local',
-                model_name: 'hf:CompendiumLabs/bge-small-zh-v1.5-gguf/bge-small-zh-v1.5-f16.gguf'
+                provider: 'las',
+                model_name: 'doubao-embedding-vision-250615',
+                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/src/utils/credentials.ts

@@ -0,0 +1,50 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import * as readline from 'readline';
+
+const CONFIG_DIR = path.join(os.homedir(), '.openclaw', 'contextlake');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'credentials.json');
+
+export interface Credentials {
+    LAS_API_KEY?: string;
+    VOLCENGINE_ACCESS_KEY?: string;
+    VOLCENGINE_SECRET_KEY?: string;
+}
+
+export function loadCredentials(): Credentials {
+    if (fs.existsSync(CONFIG_FILE)) {
+        try {
+            const content = fs.readFileSync(CONFIG_FILE, 'utf-8');
+            return JSON.parse(content);
+        } catch (e) {
+            // ignore
+        }
+    }
+    return {};
+}
+
+export function saveCredentials(creds: Credentials) {
+    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 });
+}
+
+export async function promptForInput(promptText: string, defaultVal?: string): Promise<string> {
+    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/bin/contextlake-openclaw.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-
-// 临时执行脚本，如果是生产环境可能需要直接执行 dist 下的 js 文件
-require('ts-node').register();
-require('../scripts/cli.ts');

package/dist/src/skills/las-data-profiler/register.d.ts

@@ -1 +0,0 @@
-export declare function registerLasDataProfilerSkill(ctx: any): void;

package/dist/src/skills/las-data-profiler/register.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerLasDataProfilerSkill = registerLasDataProfilerSkill;
-const index_1 = require("./index");
-function registerLasDataProfilerSkill(ctx) {
-    const definition = {
-        name: 'las-data-profiler',
-        description: 'Connect to a data source (TOS/OSS/COS/S3/Local) and profile its structure, schemas, and media metadata into LanceDB',
-        async execute(params) {
-            return await (0, index_1.connectDataSource)(params, ctx);
-        }
-    };
-    if (typeof ctx.registerTool === 'function') {
-        ctx.registerTool(definition);
-    }
-    else if (typeof ctx.registerSkill === 'function') {
-        ctx.registerSkill(definition);
-    }
-}

package/src/service/embedding/local.ts

@@ -1,118 +0,0 @@
-import { EmbeddingProvider, EmbeddingConfig } from './interface';
-// 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";
-
-let nodeLlamaImportPromise: Promise<any> | null = null;
-
-export const setNodeLlamaCppImporter = (importer: () => Promise<any>) => {
-  nodeLlamaImportPromise = importer();
-};
-
-const importNodeLlamaCpp = async (): Promise<any> => {
-  if (!nodeLlamaImportPromise) {
-    nodeLlamaImportPromise = import("node-llama-cpp");
-  }
-  return nodeLlamaImportPromise;
-};
-
-export class LocalEmbeddingProvider implements EmbeddingProvider {
-  private llama: any = null;
-  private model: any = null;
-  private context: any = null;
-  private initPromise: Promise<void> | null = null;
-  private modelPath: string;
-
-  constructor(config: EmbeddingConfig) {
-    // Override transformers.js default with node-llama-cpp default
-    this.modelPath = config.model_name === 'Xenova/all-MiniLM-L6-v2' 
-      ? DEFAULT_LOCAL_MODEL 
-      : (config.model_name || DEFAULT_LOCAL_MODEL);
-  }
-
-  private async ensureInitialized(): Promise<void> {
-    if (this.context) {
-      return;
-    }
-    if (this.initPromise) {
-      return this.initPromise;
-    }
-
-    this.initPromise = this.doInitialize();
-    return this.initPromise;
-  }
-
-  private async doInitialize(): Promise<void> {
-    try {
-      const { getLlama, resolveModelFile, LlamaLogLevel } = await importNodeLlamaCpp();
-
-      if (!this.llama) {
-        this.llama = await getLlama({ logLevel: LlamaLogLevel.error });
-      }
-
-      if (!this.model) {
-        const resolved = await resolveModelFile(this.modelPath);
-        this.model = await this.llama.loadModel({ modelPath: resolved });
-      }
-
-      if (!this.context) {
-        this.context = await this.model.createEmbeddingContext();
-      }
-    } catch (err) {
-      const detail = err instanceof Error ? err.message : String(err);
-      throw new Error(`Local embeddings unavailable. Reason: ${detail}`, {
-        cause: err,
-      });
-    }
-  }
-
-  async generateEmbedding(text: string): Promise<number[]> {
-    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)) {
-            sumSq += val * val;
-        } else {
-            vector[i] = 0;
-        }
-    }
-
-    const magnitude = Math.sqrt(sumSq);
-    const result = new Array(len);
-
-    if (magnitude > 0) {
-        const scale = 1.0 / magnitude;
-        for (let i = 0; i < len; i++) {
-            result[i] = vector[i] * scale;
-        }
-    } else {
-        // Zero vector case
-        for (let i = 0; i < len; i++) {
-            result[i] = vector[i]; // or 0
-        }
-    }
-
-    return result;
-  }
-
-  // Optimized batch processing for local embedding
-  async generateEmbeddings(texts: string[]): Promise<number[][]> {
-    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.
-    
-    return Promise.all(texts.map(text => this.generateEmbedding(text)));
-  }
-}

package/src/skills/las-data-profiler/register.ts

@@ -1,19 +0,0 @@
-// @ts-ignore
-import { PluginContext } from 'openclaw/plugin-sdk';
-import { connectDataSource } from './index';
-
-export function registerLasDataProfilerSkill(ctx: any) {
-  const definition = {
-    name: 'las-data-profiler',
-    description: 'Connect to a data source (TOS/OSS/COS/S3/Local) and profile its structure, schemas, and media metadata into LanceDB',
-    async execute(params: any) {
-      return await connectDataSource(params, ctx);
-    }
-  };
-
-  if (typeof ctx.registerTool === 'function') {
-    ctx.registerTool(definition);
-  } else if (typeof ctx.registerSkill === 'function') {
-    ctx.registerSkill(definition);
-  }
-}