@undefineds.co/xpod 0.1.0-local.202602081751

package/dist/api/service/VectorStoreService.js

@@ -0,0 +1,985 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VectorStoreService = void 0;
+const global_logger_factory_1 = require("global-logger-factory");
+const drizzle_solid_1 = require("@undefineds.co/drizzle-solid");
+const crypto_1 = require("crypto");
+const AuthContext_1 = require("../auth/AuthContext");
+const solid_client_authn_node_1 = require("@inrupt/solid-client-authn-node");
+const schema_1 = require("../../ai/schema");
+const tables_1 = require("../../credential/schema/tables");
+const types_1 = require("../../credential/schema/types");
+const schema = {
+    aiConfig: schema_1.AIConfig,
+    vectorStore: schema_1.VectorStore,
+    indexedFile: schema_1.IndexedFile,
+    model: schema_1.Model,
+    provider: schema_1.Provider,
+    credential: tables_1.Credential,
+};
+/**
+ * VectorStoreService - 知识库管理服务
+ *
+ * 提供 OpenAI 兼容的 Vector Store API
+ */
+class VectorStoreService {
+    constructor(options) {
+        this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
+        this.cssBaseUrl = options.cssBaseUrl.replace(/\/$/, '');
+        this.tokenEndpoint = options.tokenEndpoint;
+        this.embeddingService = options.embeddingService;
+        this.webhookUrl = options.webhookUrl;
+    }
+    // ============================================
+    // Vector Store CRUD
+    // ============================================
+    /**
+     * 创建 Vector Store（配置文件夹为知识库）
+     */
+    async createVectorStore(request, auth, accessToken) {
+        const db = await this.getPodDb(auth);
+        if (!db) {
+            throw new Error('Failed to authenticate with Pod');
+        }
+        // 生成 ID
+        const id = this.generateId();
+        const now = new Date();
+        const containerUri = request.url;
+        // 插入记录（不再存储 model，model 从全局配置获取）
+        await db.insert(schema_1.VectorStore).values({
+            id,
+            name: request.name || this.extractContainerName(containerUri),
+            container: containerUri,
+            chunkingStrategy: request.chunking_strategy || schema_1.ChunkingStrategy.AUTO,
+            status: schema_1.VectorStoreStatus.COMPLETED,
+            createdAt: now,
+            lastActiveAt: now,
+        });
+        this.logger.info(`Created vector store ${id} for container ${containerUri}`);
+        // 尝试注册 webhook 订阅（如果配置了 webhookUrl）
+        if (this.webhookUrl && accessToken) {
+            try {
+                await this.subscribeToContainer(containerUri, accessToken);
+                this.logger.info(`Subscribed to container ${containerUri} for webhook notifications`);
+            }
+            catch (error) {
+                // 订阅失败不影响 VectorStore 创建，只记录警告
+                this.logger.warn(`Failed to subscribe to container ${containerUri}: ${error}`);
+            }
+        }
+        return this.buildVectorStoreObject(id, {
+            name: request.name || this.extractContainerName(containerUri),
+            containerUrl: containerUri,
+            chunkingStrategy: request.chunking_strategy || 'auto',
+            status: 'completed',
+            createdAt: now,
+            lastActiveAt: now,
+        });
+    }
+    /**
+     * 列出所有 Vector Store
+     */
+    async listVectorStores(auth, options) {
+        const db = await this.getPodDb(auth);
+        if (!db) {
+            throw new Error('Failed to authenticate with Pod');
+        }
+        const stores = await db.select().from(schema_1.VectorStore);
+        // 排序
+        const order = options?.order || 'desc';
+        stores.sort((a, b) => {
+            const aTime = a.createdAt?.getTime() || 0;
+            const bTime = b.createdAt?.getTime() || 0;
+            return order === 'desc' ? bTime - aTime : aTime - bTime;
+        });
+        // 分页
+        const limit = options?.limit || 20;
+        const data = stores.slice(0, limit).map(store => this.buildVectorStoreObject(store.id, {
+            name: store.name || '',
+            containerUrl: store.container || '',
+            chunkingStrategy: store.chunkingStrategy || 'auto',
+            status: store.status || 'completed',
+            createdAt: store.createdAt || new Date(),
+            lastActiveAt: store.lastActiveAt || null,
+        }));
+        return {
+            object: 'list',
+            data,
+            has_more: stores.length > limit,
+        };
+    }
+    /**
+     * 获取单个 Vector Store
+     */
+    async getVectorStore(id, auth) {
+        const db = await this.getPodDb(auth);
+        if (!db) {
+            throw new Error('Failed to authenticate with Pod');
+        }
+        const stores = await db.select().from(schema_1.VectorStore).where((0, drizzle_solid_1.eq)(schema_1.VectorStore.id, id));
+        if (stores.length === 0) {
+            throw new Error(`Vector store ${id} not found`);
+        }
+        const store = stores[0];
+        // 获取 file_counts（基于 Container 前缀匹配）
+        const fileCounts = await this.getFileCounts(store.container || '', auth);
+        return this.buildVectorStoreObject(store.id, {
+            name: store.name || '',
+            containerUrl: store.container || '',
+            chunkingStrategy: store.chunkingStrategy || 'auto',
+            status: store.status || 'completed',
+            createdAt: store.createdAt || new Date(),
+            lastActiveAt: store.lastActiveAt || null,
+            fileCounts,
+        });
+    }
+    /**
+     * 修改 Vector Store
+     */
+    async modifyVectorStore(id, request, auth) {
+        const db = await this.getPodDb(auth);
+        if (!db) {
+            throw new Error('Failed to authenticate with Pod');
+        }
+        // 构建更新数据（不再支持修改 model，model 是全局配置）
+        const updates = {};
+        if (request.name !== undefined)
+            updates.name = request.name;
+        if (request.chunking_strategy !== undefined)
+            updates.chunkingStrategy = request.chunking_strategy;
+        await db.update(schema_1.VectorStore).set(updates).where((0, drizzle_solid_1.eq)(schema_1.VectorStore.id, id));
+        return this.getVectorStore(id, auth);
+    }
+    /**
+     * 删除 Vector Store
+     */
+    async deleteVectorStore(id, auth) {
+        const db = await this.getPodDb(auth);
+        if (!db) {
+            throw new Error('Failed to authenticate with Pod');
+        }
+        await db.delete(schema_1.VectorStore).where((0, drizzle_solid_1.eq)(schema_1.VectorStore.id, id));
+        this.logger.info(`Deleted vector store ${id}`);
+        return {
+            id,
+            object: 'vector_store.deleted',
+            deleted: true,
+        };
+    }
+    // ============================================
+    // File Index Management (for webhook)
+    // ============================================
+    /**
+     * 索引文件（由 webhook 调用）
+     *
+     * @param vectorStoreId Vector Store ID
+     * @param fileUrl 文件 URL
+     * @param auth 认证上下文
+     * @param accessToken 访问令牌
+     */
+    async indexFile(fileUrl, auth, accessToken) {
+        const db = await this.getPodDb(auth);
+        if (!db) {
+            throw new Error('Failed to authenticate with Pod');
+        }
+        // 获取全局 AI 配置（embedding model）
+        const aiConfig = await this.getAIConfig(auth);
+        if (!aiConfig) {
+            throw new Error('No AI configuration found. Please configure an embedding model first.');
+        }
+        // 查找最近的父级 VectorStore 获取分块策略
+        const chunkingStrategy = await this.getChunkingStrategyForFile(fileUrl, auth);
+        // 检查文件是否已索引
+        const existingFiles = await db.select().from(schema_1.IndexedFile).where((0, drizzle_solid_1.eq)(schema_1.IndexedFile.fileUrl, fileUrl));
+        const vectorId = this.hashSubjectAspect(fileUrl, 'content');
+        let fileIndexId;
+        if (existingFiles.length > 0) {
+            // 文件已存在，更新状态
+            fileIndexId = existingFiles[0].id;
+            await db.update(schema_1.IndexedFile).set({
+                status: schema_1.FileIndexStatus.IN_PROGRESS,
+                chunkingStrategy,
+                indexedAt: new Date(),
+            }).where((0, drizzle_solid_1.eq)(schema_1.IndexedFile.id, fileIndexId));
+        }
+        else {
+            // 创建新的索引记录
+            fileIndexId = `idx_${(0, crypto_1.randomBytes)(8).toString('hex')}`;
+            await db.insert(schema_1.IndexedFile).values({
+                id: fileIndexId,
+                fileUrl,
+                vectorId,
+                chunkingStrategy,
+                status: schema_1.FileIndexStatus.IN_PROGRESS,
+                usageBytes: 0,
+                indexedAt: new Date(),
+            });
+        }
+        try {
+            // 获取 AI credential
+            const credential = await this.getAiCredential(auth);
+            if (!credential) {
+                throw new Error('No AI credential found');
+            }
+            // 读取文件内容
+            const content = await this.fetchResourceContent(fileUrl, accessToken);
+            if (!content || content.trim().length === 0) {
+                throw new Error(`File ${fileUrl} has no indexable content`);
+            }
+            // 生成 embedding（使用全局 model）
+            const embedding = await this.embeddingService.embed(content, credential, aiConfig.embeddingModel);
+            // 存储向量
+            await this.upsertVector(aiConfig.embeddingModel, vectorId, embedding, accessToken);
+            // 更新索引记录为 completed
+            await db.update(schema_1.IndexedFile).set({
+                status: schema_1.FileIndexStatus.COMPLETED,
+                usageBytes: content.length,
+                lastError: null,
+            }).where((0, drizzle_solid_1.eq)(schema_1.IndexedFile.id, fileIndexId));
+            this.logger.info(`Indexed file ${fileUrl} with model ${aiConfig.embeddingModel}`);
+            return { id: fileIndexId, status: 'completed', vectorId };
+        }
+        catch (error) {
+            // 更新索引记录为 failed
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            await db.update(schema_1.IndexedFile).set({
+                status: schema_1.FileIndexStatus.FAILED,
+                lastError: errorMsg,
+            }).where((0, drizzle_solid_1.eq)(schema_1.IndexedFile.id, fileIndexId));
+            this.logger.error(`Failed to index file ${fileUrl}: ${errorMsg}`);
+            throw error;
+        }
+    }
+    /**
+     * 获取文件应使用的分块策略（查找最近的父级 VectorStore）
+     */
+    async getChunkingStrategyForFile(fileUrl, auth) {
+        const db = await this.getPodDb(auth);
+        if (!db)
+            return schema_1.ChunkingStrategy.AUTO;
+        // 获取所有 VectorStore
+        const allStores = await db.select().from(schema_1.VectorStore);
+        // 找到所有是 fileUrl 前缀的 VectorStore
+        const matchedStores = allStores.filter(store => {
+            if (!store.container)
+                return false;
+            const containerUrl = store.container.endsWith('/') ? store.container : store.container + '/';
+            return fileUrl.startsWith(containerUrl);
+        });
+        if (matchedStores.length === 0) {
+            return schema_1.ChunkingStrategy.AUTO;
+        }
+        // 找最长前缀（最近的父级）
+        matchedStores.sort((a, b) => (b.container?.length || 0) - (a.container?.length || 0));
+        return matchedStores[0].chunkingStrategy || schema_1.ChunkingStrategy.AUTO;
+    }
+    /**
+     * 删除文件索引（由 webhook 调用）
+     */
+    async removeFileIndex(fileUrl, auth, accessToken) {
+        const db = await this.getPodDb(auth);
+        if (!db) {
+            throw new Error('Failed to authenticate with Pod');
+        }
+        // 获取全局 AI 配置
+        const aiConfig = await this.getAIConfig(auth);
+        if (!aiConfig) {
+            this.logger.warn(`No AI config found, cannot delete vector for ${fileUrl}`);
+            return { deleted: false };
+        }
+        // 查找文件索引记录
+        const files = await db.select().from(schema_1.IndexedFile).where((0, drizzle_solid_1.eq)(schema_1.IndexedFile.fileUrl, fileUrl));
+        if (files.length === 0) {
+            this.logger.warn(`File index record not found for ${fileUrl}`);
+            return { deleted: false };
+        }
+        const fileRecord = files[0];
+        // 从向量存储中删除
+        if (fileRecord.vectorId) {
+            await this.deleteVector(aiConfig.embeddingModel, fileRecord.vectorId, accessToken);
+        }
+        // 删除索引记录
+        await db.delete(schema_1.IndexedFile).where((0, drizzle_solid_1.eq)(schema_1.IndexedFile.id, fileRecord.id));
+        this.logger.info(`Removed file index ${fileUrl}`);
+        return { deleted: true };
+    }
+    /**
+     * 获取 Container 下的 file_counts 统计（基于 fileUrl 前缀匹配）
+     */
+    async getFileCounts(containerUrl, auth) {
+        const db = await this.getPodDb(auth);
+        if (!db) {
+            return { in_progress: 0, completed: 0, failed: 0, cancelled: 0, total: 0 };
+        }
+        // 获取所有索引文件，过滤属于该 Container 的
+        const allFiles = await db.select().from(schema_1.IndexedFile);
+        const containerPrefix = containerUrl.endsWith('/') ? containerUrl : containerUrl + '/';
+        const files = allFiles.filter(f => f.fileUrl?.startsWith(containerPrefix));
+        const counts = {
+            in_progress: 0,
+            completed: 0,
+            failed: 0,
+            cancelled: 0,
+            total: files.length,
+        };
+        for (const file of files) {
+            switch (file.status) {
+                case schema_1.FileIndexStatus.IN_PROGRESS:
+                    counts.in_progress++;
+                    break;
+                case schema_1.FileIndexStatus.COMPLETED:
+                    counts.completed++;
+                    break;
+                case schema_1.FileIndexStatus.FAILED:
+                    counts.failed++;
+                    break;
+                case schema_1.FileIndexStatus.CANCELLED:
+                    counts.cancelled++;
+                    break;
+            }
+        }
+        return counts;
+    }
+    /**
+     * 通过 vectorId 查找文件 URL（供 search 使用）
+     * 注意：文件只索引一份，用 vectorId 即可查找
+     */
+    async getFileUrlByVectorId(vectorId, auth) {
+        const db = await this.getPodDb(auth);
+        if (!db)
+            return null;
+        const files = await db.select().from(schema_1.IndexedFile).where((0, drizzle_solid_1.eq)(schema_1.IndexedFile.vectorId, vectorId));
+        return files.length > 0 ? files[0].fileUrl : null;
+    }
+    /**
+     * 根据 Container URL 查找 VectorStore
+     */
+    async findVectorStoreByContainer(containerUrl, auth) {
+        const db = await this.getPodDb(auth);
+        if (!db)
+            return null;
+        const stores = await db.select().from(schema_1.VectorStore).where((0, drizzle_solid_1.eq)(schema_1.VectorStore.container, containerUrl));
+        if (stores.length === 0)
+            return null;
+        const store = stores[0];
+        return this.buildVectorStoreObject(store.id, {
+            name: store.name || '',
+            containerUrl: store.container || '',
+            chunkingStrategy: store.chunkingStrategy || 'auto',
+            status: store.status || 'completed',
+            createdAt: store.createdAt || new Date(),
+            lastActiveAt: store.lastActiveAt || null,
+        });
+    }
+    /**
+     * 根据文件 URL 查找所有匹配的 VectorStore（包括父级容器）
+     *
+     * 例如：文件 https://alice.pod/A/B/c.txt 会匹配：
+     * - https://alice.pod/A/B/  (直接父级)
+     * - https://alice.pod/A/    (祖先级)
+     * - https://alice.pod/      (Pod 根)
+     *
+     * 这样文件可以被索引到多个知识库中
+     */
+    async findVectorStoresByFileUrl(fileUrl, auth) {
+        const db = await this.getPodDb(auth);
+        if (!db)
+            return [];
+        // 获取所有 VectorStore
+        const allStores = await db.select().from(schema_1.VectorStore);
+        // 过滤出 container 是 fileUrl 前缀的 VectorStore
+        const matchedStores = allStores.filter(store => {
+            if (!store.container)
+                return false;
+            // 确保 container URL 以 / 结尾
+            const containerUrl = store.container.endsWith('/') ? store.container : store.container + '/';
+            return fileUrl.startsWith(containerUrl);
+        });
+        // 转换为 VectorStoreObject
+        return matchedStores.map(store => this.buildVectorStoreObject(store.id, {
+            name: store.name || '',
+            containerUrl: store.container || '',
+            chunkingStrategy: store.chunkingStrategy || 'auto',
+            status: store.status || 'completed',
+            createdAt: store.createdAt || new Date(),
+            lastActiveAt: store.lastActiveAt || null,
+        }));
+    }
+    // ============================================
+    // Search
+    // ============================================
+    /**
+     * 搜索 Vector Store
+     */
+    async search(vectorStoreId, request, auth, accessToken) {
+        const store = await this.getVectorStore(vectorStoreId, auth);
+        // 获取 AI credential
+        const credential = await this.getAiCredential(auth);
+        if (!credential) {
+            throw new Error('No AI credential found');
+        }
+        // 获取全局 AI 配置中的 embedding model
+        const aiConfig = await this.getAIConfig(auth);
+        if (!aiConfig?.embeddingModel) {
+            throw new Error('No embedding model configured. Please set up AI configuration first.');
+        }
+        const queryText = Array.isArray(request.query) ? request.query.join(' ') : request.query;
+        // 生成 query embedding（使用全局模型）
+        const queryEmbedding = await this.embeddingService.embed(queryText, credential, aiConfig.embeddingModel);
+        // 调用 CSS vector search，使用 subjectPrefix 过滤只搜索该 VectorStore 的文件
+        const limit = request.max_num_results || 10;
+        const results = await this.searchVectors(aiConfig.embeddingModel, queryEmbedding, limit, accessToken, {
+            subjectPrefix: store.url, // Container URL 作为 subject 前缀
+        });
+        // 构建搜索结果，使用 vectorId -> fileUrl 映射
+        const searchResults = [];
+        for (const r of results) {
+            const vectorId = typeof r.id === 'number' ? r.id : parseInt(String(r.id), 10);
+            const fileUrl = await this.getFileUrlByVectorId(vectorId, auth);
+            searchResults.push({
+                file_id: String(r.id),
+                file_url: fileUrl || '',
+                filename: fileUrl ? this.extractFilename(fileUrl) : '',
+                score: r.score,
+                attributes: {},
+                content: [], // TODO: 可选返回内容片段
+            });
+        }
+        return {
+            object: 'vector_store.search_results.page',
+            search_query: queryText,
+            data: searchResults,
+            has_more: false,
+        };
+    }
+    // ============================================
+    // Private Methods
+    // ============================================
+    generateId() {
+        return `vs_${(0, crypto_1.randomBytes)(12).toString('hex')}`;
+    }
+    /**
+     * Hash subject + aspect 为向量 ID（供 webhook 索引使用）
+     */
+    hashSubjectAspect(subject, aspect) {
+        const str = `${subject}|${aspect}`;
+        let hash = 2166136261;
+        for (let i = 0; i < str.length; i++) {
+            hash ^= str.charCodeAt(i);
+            hash = Math.imul(hash, 16777619);
+        }
+        return Math.abs(hash);
+    }
+    extractContainerName(url) {
+        const parts = url.replace(/\/$/, '').split('/');
+        return parts[parts.length - 1] || 'Unnamed';
+    }
+    extractFilename(url) {
+        const parts = url.split('/');
+        return parts[parts.length - 1] || '';
+    }
+    extractModelId(uri) {
+        const hashIndex = uri.lastIndexOf('#');
+        if (hashIndex !== -1) {
+            return uri.slice(hashIndex + 1);
+        }
+        return uri;
+    }
+    getPodBaseUrl(webId) {
+        const url = new URL(webId);
+        url.hash = '';
+        let path = url.pathname;
+        if (path.endsWith('/profile/card')) {
+            path = path.slice(0, -'/profile/card'.length);
+        }
+        if (!path.endsWith('/')) {
+            path = path + '/';
+        }
+        return `${url.origin}${path}`;
+    }
+    buildVectorStoreObject(id, data) {
+        return {
+            id,
+            object: 'vector_store',
+            created_at: Math.floor(data.createdAt.getTime() / 1000),
+            name: data.name,
+            status: data.status,
+            usage_bytes: data.usageBytes || 0,
+            file_counts: data.fileCounts || {
+                in_progress: 0,
+                completed: 0,
+                failed: 0,
+                cancelled: 0,
+                total: 0,
+            },
+            last_active_at: data.lastActiveAt ? Math.floor(data.lastActiveAt.getTime() / 1000) : null,
+            metadata: {},
+            url: data.containerUrl,
+            chunking_strategy: data.chunkingStrategy,
+        };
+    }
+    async getPodDb(auth) {
+        if (!(0, AuthContext_1.isSolidAuth)(auth) || !auth.clientId || !auth.clientSecret) {
+            this.logger.debug('No clientId or clientSecret in auth context');
+            return null;
+        }
+        const session = new solid_client_authn_node_1.Session();
+        try {
+            await session.login({
+                oidcIssuer: new URL(this.tokenEndpoint).origin,
+                clientId: auth.clientId,
+                clientSecret: auth.clientSecret,
+            });
+            if (!session.info.isLoggedIn || !session.info.webId) {
+                throw new Error('Login failed');
+            }
+            return (0, drizzle_solid_1.drizzle)({ fetch: session.fetch, info: { webId: session.info.webId, isLoggedIn: true } }, { schema });
+        }
+        catch (error) {
+            this.logger.error(`Failed to login: ${error}`);
+            return null;
+        }
+    }
+    async getAiCredential(auth) {
+        const db = await this.getPodDb(auth);
+        if (!db)
+            return undefined;
+        try {
+            const credentials = await db.select().from(tables_1.Credential).where((0, drizzle_solid_1.eq)(tables_1.Credential.service, types_1.ServiceType.AI));
+            const activeCred = credentials.find(c => c.status === types_1.CredentialStatus.ACTIVE);
+            if (!activeCred || !activeCred.apiKey)
+                return undefined;
+            // 获取 provider 信息
+            let baseUrl;
+            let proxyUrl;
+            if (activeCred.provider) {
+                const providers = await db.select().from(schema_1.Provider);
+                const provider = providers.find(p => activeCred.provider?.includes(p.id));
+                if (provider) {
+                    baseUrl = provider.baseUrl || undefined;
+                    proxyUrl = provider.proxyUrl || undefined;
+                }
+            }
+            return {
+                provider: activeCred.id,
+                apiKey: activeCred.apiKey,
+                baseUrl: activeCred.baseUrl || baseUrl,
+                proxyUrl,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to get AI credential: ${error}`);
+            return undefined;
+        }
+    }
+    /**
+     * 获取 Pod 级别的 AI 配置（全局 embedding model）
+     */
+    async getAIConfig(auth) {
+        const db = await this.getPodDb(auth);
+        if (!db)
+            return null;
+        try {
+            const configs = await db.select().from(schema_1.AIConfig);
+            const config = configs.find(c => c.id === 'config');
+            if (!config || !config.embeddingModel) {
+                // 如果没有配置，尝试使用默认模型
+                const models = await db.select().from(schema_1.Model);
+                const defaultModel = models.find(m => m.modelType === 'embedding') || models[0];
+                if (defaultModel) {
+                    return {
+                        embeddingModel: defaultModel.id,
+                        migrationStatus: 'idle',
+                    };
+                }
+                return null;
+            }
+            return {
+                embeddingModel: this.extractModelId(config.embeddingModel),
+                migrationStatus: config.migrationStatus || 'idle',
+                previousModel: config.previousModel ? this.extractModelId(config.previousModel) : undefined,
+                migrationProgress: config.migrationProgress || undefined,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to get AI config: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * 设置全局 embedding model
+     * 如果更换了模型，自动触发迁移（后台重新索引所有文件）
+     */
+    async setEmbeddingModel(newModel, auth, accessToken) {
+        const db = await this.getPodDb(auth);
+        if (!db) {
+            throw new Error('Failed to authenticate with Pod');
+        }
+        const currentConfig = await this.getAIConfig(auth);
+        const currentModel = currentConfig?.embeddingModel;
+        // 检查模型是否有变化
+        const modelChanged = currentModel && currentModel !== newModel;
+        const webId = (0, AuthContext_1.getWebId)(auth) ?? (0, AuthContext_1.getAccountId)(auth) ?? '';
+        const podBaseUrl = this.getPodBaseUrl(webId);
+        const modelUri = `${podBaseUrl}settings/ai/models.ttl#${newModel}`;
+        try {
+            // 检查配置是否已存在
+            const configs = await db.select().from(schema_1.AIConfig);
+            const existingConfig = configs.find(c => c.id === 'config');
+            if (existingConfig) {
+                // 更新现有配置
+                await db.update(schema_1.AIConfig).set({
+                    embeddingModel: modelUri,
+                    previousModel: modelChanged ? `${podBaseUrl}settings/ai/models.ttl#${currentModel}` : existingConfig.previousModel,
+                    migrationStatus: modelChanged ? schema_1.MigrationStatus.IN_PROGRESS : existingConfig.migrationStatus,
+                    migrationProgress: modelChanged ? 0 : existingConfig.migrationProgress,
+                    updatedAt: new Date(),
+                }).where((0, drizzle_solid_1.eq)(schema_1.AIConfig.id, 'config'));
+            }
+            else {
+                // 创建新配置
+                await db.insert(schema_1.AIConfig).values({
+                    id: 'config',
+                    embeddingModel: modelUri,
+                    migrationStatus: schema_1.MigrationStatus.IDLE,
+                    migrationProgress: 0,
+                    updatedAt: new Date(),
+                });
+            }
+            this.logger.info(`Set embedding model to ${newModel}`);
+            // 如果模型变化，在后台启动迁移
+            if (modelChanged) {
+                this.logger.info(`Model changed from ${currentModel} to ${newModel}, triggering migration`);
+                // 异步执行迁移，不阻塞响应
+                this.startMigration(auth, accessToken).catch(error => {
+                    this.logger.error(`Migration failed: ${error}`);
+                });
+            }
+            return {
+                success: true,
+                migrationTriggered: modelChanged === true,
+                message: modelChanged
+                    ? `Model updated to ${newModel}. Migration started to re-index all files.`
+                    : `Model set to ${newModel}.`,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Failed to set embedding model: ${error}`);
+            throw error;
+        }
+    }
+    /**
+     * 开始迁移：重新索引所有文件
+     */
+    async startMigration(auth, accessToken) {
+        const db = await this.getPodDb(auth);
+        if (!db)
+            return;
+        try {
+            // 获取所有已索引的文件
+            const allFiles = await db.select().from(schema_1.IndexedFile);
+            const totalFiles = allFiles.length;
+            if (totalFiles === 0) {
+                // 无文件需要迁移
+                await db.update(schema_1.AIConfig).set({
+                    migrationStatus: schema_1.MigrationStatus.COMPLETED,
+                    migrationProgress: 100,
+                    updatedAt: new Date(),
+                }).where((0, drizzle_solid_1.eq)(schema_1.AIConfig.id, 'config'));
+                return;
+            }
+            this.logger.info(`Starting migration for ${totalFiles} files`);
+            let completedFiles = 0;
+            let failedFiles = 0;
+            for (const file of allFiles) {
+                try {
+                    // 重新索引每个文件
+                    await this.indexFile(file.fileUrl, auth, accessToken);
+                    completedFiles++;
+                }
+                catch (error) {
+                    failedFiles++;
+                    this.logger.error(`Failed to re-index ${file.fileUrl}: ${error}`);
+                }
+                // 更新迁移进度
+                const progress = Math.round(((completedFiles + failedFiles) / totalFiles) * 100);
+                await db.update(schema_1.AIConfig).set({
+                    migrationProgress: progress,
+                    updatedAt: new Date(),
+                }).where((0, drizzle_solid_1.eq)(schema_1.AIConfig.id, 'config'));
+            }
+            // 标记迁移完成
+            const finalStatus = failedFiles === 0 ? schema_1.MigrationStatus.COMPLETED : schema_1.MigrationStatus.FAILED;
+            await db.update(schema_1.AIConfig).set({
+                migrationStatus: finalStatus,
+                migrationProgress: 100,
+                updatedAt: new Date(),
+            }).where((0, drizzle_solid_1.eq)(schema_1.AIConfig.id, 'config'));
+            this.logger.info(`Migration completed: ${completedFiles} success, ${failedFiles} failed`);
+        }
+        catch (error) {
+            this.logger.error(`Migration error: ${error}`);
+            await db.update(schema_1.AIConfig).set({
+                migrationStatus: schema_1.MigrationStatus.FAILED,
+                updatedAt: new Date(),
+            }).where((0, drizzle_solid_1.eq)(schema_1.AIConfig.id, 'config'));
+        }
+    }
+    /**
+     * 获取资源内容（供 webhook 索引使用）
+     */
+    async fetchResourceContent(url, accessToken) {
+        const response = await fetch(url, {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                Accept: 'text/turtle, application/ld+json, text/plain, text/markdown, text/html, */*',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${url}: ${response.status}`);
+        }
+        const contentType = response.headers.get('Content-Type') || '';
+        const body = await response.text();
+        return this.extractText(body, contentType);
+    }
+    extractText(body, contentType) {
+        const ct = contentType.toLowerCase();
+        if (ct.includes('text/turtle') || ct.includes('application/n-triples')) {
+            return this.extractTextFromTurtle(body);
+        }
+        if (ct.includes('application/ld+json') || ct.includes('application/json')) {
+            return this.extractTextFromJsonLd(body);
+        }
+        if (ct.includes('text/html')) {
+            return this.extractTextFromHtml(body);
+        }
+        return body;
+    }
+    extractTextFromTurtle(turtle) {
+        const literals = [];
+        const tripleQuoteRegex = /"""([^]*?)"""/g;
+        const singleQuoteRegex = /"([^"\\]*(?:\\.[^"\\]*)*)"/g;
+        let match;
+        while ((match = tripleQuoteRegex.exec(turtle)) !== null) {
+            if (match[1].trim().length > 0)
+                literals.push(match[1].trim());
+        }
+        const withoutTriple = turtle.replace(/"""[^]*?"""/g, '');
+        while ((match = singleQuoteRegex.exec(withoutTriple)) !== null) {
+            const value = match[1].trim();
+            if (value.length > 3 && !value.startsWith('http') && !value.startsWith('urn:')) {
+                literals.push(value);
+            }
+        }
+        return literals.join('\n');
+    }
+    extractTextFromJsonLd(jsonStr) {
+        try {
+            const json = JSON.parse(jsonStr);
+            const texts = [];
+            const extract = (obj) => {
+                if (typeof obj === 'string' && obj.length > 3 && !obj.startsWith('http')) {
+                    texts.push(obj);
+                }
+                else if (Array.isArray(obj)) {
+                    obj.forEach(extract);
+                }
+                else if (obj && typeof obj === 'object') {
+                    for (const [key, value] of Object.entries(obj)) {
+                        if (!key.startsWith('@'))
+                            extract(value);
+                    }
+                }
+            };
+            extract(json);
+            return texts.join('\n');
+        }
+        catch {
+            return jsonStr;
+        }
+    }
+    extractTextFromHtml(html) {
+        let text = html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '');
+        text = text.replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '');
+        text = text.replace(/<[^>]+>/g, ' ');
+        text = text.replace(/\s+/g, ' ').trim();
+        return text;
+    }
+    /**
+     * Upsert 向量到 CSS（供 webhook 索引使用）
+     */
+    async upsertVector(model, id, vector, accessToken) {
+        const url = `${this.cssBaseUrl}/-/vector/upsert`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+            },
+            body: JSON.stringify({ model, vectors: [{ id, vector }] }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Vector upsert failed: ${response.status} ${errorText}`);
+        }
+    }
+    /**
+     * 删除向量（供 webhook 索引使用）
+     */
+    async deleteVector(model, id, accessToken) {
+        const url = `${this.cssBaseUrl}/-/vector/delete`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+            },
+            body: JSON.stringify({ model, ids: [id] }),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Vector delete failed: ${response.status} ${errorText}`);
+        }
+    }
+    async searchVectors(model, vector, limit, accessToken, options) {
+        const url = `${this.cssBaseUrl}/-/vector/search`;
+        const body = { model, vector, limit };
+        // 添加 subject 前缀过滤（限定搜索范围到特定 Container）
+        if (options?.subjectPrefix) {
+            body.filter = {
+                subject: { $startsWith: options.subjectPrefix },
+            };
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${accessToken}`,
+            },
+            body: JSON.stringify(body),
+        });
+        if (!response.ok) {
+            throw new Error(`Vector search failed: ${response.status}`);
+        }
+        const data = await response.json();
+        return data.results || [];
+    }
+    // ============================================
+    // Webhook Subscription
+    // ============================================
+    /**
+     * 订阅 Container 的变更通知（WebhookChannel2023）
+     *
+     * @param containerUrl Container URL
+     * @param accessToken 访问令牌
+     */
+    async subscribeToContainer(containerUrl, accessToken) {
+        if (!this.webhookUrl) {
+            throw new Error('Webhook URL not configured');
+        }
+        // 1. 发现订阅端点
+        const subscriptionEndpoint = await this.discoverNotificationEndpoint(containerUrl, accessToken);
+        if (!subscriptionEndpoint) {
+            throw new Error(`No notification endpoint found for ${containerUrl}`);
+        }
+        // 2. 创建 webhook 订阅
+        const subscriptionRequest = {
+            '@context': ['https://www.w3.org/ns/solid/notification/v1'],
+            type: 'WebhookChannel2023',
+            topic: containerUrl,
+            sendTo: this.webhookUrl,
+        };
+        const response = await fetch(subscriptionEndpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/ld+json',
+                Accept: 'application/ld+json',
+                Authorization: `Bearer ${accessToken}`,
+            },
+            body: JSON.stringify(subscriptionRequest),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`Subscription failed: ${response.status} ${errorText}`);
+        }
+        const result = await response.json();
+        this.logger.info(`Created webhook subscription: ${JSON.stringify(result)}`);
+    }
+    /**
+     * 发现 Solid Notification 端点
+     *
+     * 通过 HEAD 请求获取 Link header 中的 describedby，然后获取订阅端点
+     */
+    async discoverNotificationEndpoint(resourceUrl, accessToken) {
+        // 方法 1：直接使用已知的 CSS 端点格式
+        // CSS 的 webhook 订阅端点通常是 /.notifications/WebhookChannel2023/
+        const url = new URL(resourceUrl);
+        const webhookEndpoint = `${url.origin}/.notifications/WebhookChannel2023/`;
+        // 验证端点是否存在
+        try {
+            const response = await fetch(webhookEndpoint, {
+                method: 'GET',
+                headers: {
+                    Accept: 'application/ld+json',
+                    Authorization: `Bearer ${accessToken}`,
+                },
+            });
+            if (response.ok) {
+                return webhookEndpoint;
+            }
+        }
+        catch {
+            // 忽略错误，尝试其他方法
+        }
+        // 方法 2：通过 describedby Link header 发现
+        try {
+            const headResponse = await fetch(resourceUrl, {
+                method: 'HEAD',
+                headers: {
+                    Authorization: `Bearer ${accessToken}`,
+                },
+            });
+            const linkHeader = headResponse.headers.get('Link');
+            if (linkHeader) {
+                // 解析 Link header 找 describedby
+                const describedBy = this.parseLinkHeader(linkHeader, 'describedby');
+                if (describedBy) {
+                    // 获取 describedby 资源，解析通知端点
+                    const descResponse = await fetch(describedBy, {
+                        headers: {
+                            Accept: 'application/ld+json',
+                            Authorization: `Bearer ${accessToken}`,
+                        },
+                    });
+                    if (descResponse.ok) {
+                        const desc = await descResponse.json();
+                        // 查找 notify:subscription 或类似属性
+                        const subscription = desc['notify:subscription'] || desc['subscription'];
+                        if (subscription) {
+                            return typeof subscription === 'string' ? subscription : subscription['@id'];
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // 忽略错误
+        }
+        return null;
+    }
+    /**
+     * 解析 Link header
+     */
+    parseLinkHeader(linkHeader, rel) {
+        const links = linkHeader.split(',');
+        for (const link of links) {
+            const match = link.match(/<([^>]+)>.*rel="?([^";]+)"?/);
+            if (match && match[2] === rel) {
+                return match[1];
+            }
+        }
+        return null;
+    }
+}
+exports.VectorStoreService = VectorStoreService;
+//# sourceMappingURL=VectorStoreService.js.map