@cicctencent/agent-midway 0.1.1

package/dist/service/connector.service.js

@@ -0,0 +1,524 @@
+"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorService = void 0;
+/**
+ * 连接器服务
+ *
+ * 文件系统驱动的连接器管理服务。
+ * 扫描 data/connectors/ 目录，每个 JSON 文件代表一个连接器配置。
+ * 同时支持目录式连接器包（含 manifest.json + mcp-servers/ + skills/）。
+ * 提供连接器的 CRUD、连接测试、工具发现、清单生成等能力。
+ */
+const core_1 = require("@midwayjs/core");
+const midwayjs_base_1 = require("@cicctencent/midwayjs-base");
+const fs = __importStar(require("fs"));
+const fsp = __importStar(require("fs/promises"));
+const path = __importStar(require("path"));
+const agent_server_1 = require("@cicctencent/agent-server");
+const index_1 = require("../connector/index");
+/** 连接器存储目录 */
+const CONNECTORS_DIR = path.resolve(process.cwd(), 'data', 'connectors');
+/** 内存缓存：目录式连接器实体 */
+let connectorCache = [];
+/** 连接器 ID → 目录名 映射 */
+const connectorDirMap = new Map();
+let ConnectorService = class ConnectorService extends midwayjs_base_1.BaseService {
+    constructor() {
+        super(...arguments);
+        this.initialized = false;
+    }
+    async init() {
+        try {
+            await fsp.mkdir(CONNECTORS_DIR, { recursive: true });
+            this.initialized = true;
+            // 自动发现目录式连接器
+            await this.autoDiscoverConnectors();
+            console.log('[ConnectorService] 初始化完成');
+        }
+        catch (err) {
+            console.error('[ConnectorService] 初始化失败:', err.message);
+        }
+    }
+    /** 列出所有连接器 */
+    async list() {
+        await this.ensureDir();
+        const files = await fsp.readdir(CONNECTORS_DIR);
+        const records = [];
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            try {
+                const raw = await fsp.readFile(path.join(CONNECTORS_DIR, file), 'utf-8');
+                const record = JSON.parse(raw);
+                records.push(record);
+            }
+            catch {
+                // 跳过损坏的文件
+            }
+        }
+        return records.sort((a, b) => b.updatedAt - a.updatedAt);
+    }
+    /** 获取单个连接器 */
+    async get(id) {
+        const filePath = this.getFilePath(id);
+        try {
+            const raw = await fsp.readFile(filePath, 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch {
+            return null;
+        }
+    }
+    /** 创建连接器 */
+    async create(config) {
+        const id = this.generateId(config.name);
+        const record = {
+            id,
+            config,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        };
+        await this.ensureDir();
+        await fsp.writeFile(this.getFilePath(id), JSON.stringify(record, null, 2), 'utf-8');
+        return record;
+    }
+    /** 更新连接器 */
+    async update(id, config) {
+        const existing = await this.get(id);
+        if (!existing) {
+            return null;
+        }
+        const record = {
+            ...existing,
+            config: { ...existing.config, ...config },
+            updatedAt: Date.now(),
+        };
+        await fsp.writeFile(this.getFilePath(id), JSON.stringify(record, null, 2), 'utf-8');
+        return record;
+    }
+    /** 删除连接器 */
+    async delete(id) {
+        const filePath = this.getFilePath(id);
+        try {
+            await fsp.unlink(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** 测试连接 */
+    async testConnection(id) {
+        const record = await this.get(id);
+        if (!record) {
+            return {
+                success: false,
+                message: '连接器不存在',
+            };
+        }
+        const adapter = (0, index_1.getAdapter)(record.config.type);
+        return adapter.testConnection(record.config);
+    }
+    /** 测试配置（未保存的配置） */
+    async testConfig(config) {
+        const adapter = (0, index_1.getAdapter)(config.type);
+        return adapter.testConnection(config);
+    }
+    /** 发现工具 */
+    async discoverTools(id) {
+        const record = await this.get(id);
+        if (!record) {
+            throw new Error('连接器不存在');
+        }
+        const adapter = (0, index_1.getAdapter)(record.config.type);
+        return adapter.discoverTools(record.config);
+    }
+    /** 生成清单 */
+    async generateManifest(id) {
+        const record = await this.get(id);
+        if (!record) {
+            throw new Error('连接器不存在');
+        }
+        const adapter = (0, index_1.getAdapter)(record.config.type);
+        return adapter.generateManifest(record.config);
+    }
+    /** 生成 MCP 服务器配置 */
+    async generateMCPServerConfigs(id) {
+        const record = await this.get(id);
+        if (!record) {
+            throw new Error('连接器不存在');
+        }
+        const adapter = (0, index_1.getAdapter)(record.config.type);
+        return adapter.generateMCPServerConfigs(record.config);
+    }
+    /** 获取所有数据源类型 */
+    getDataSourceTypes() {
+        return (0, index_1.listDataSourceTypes)();
+    }
+    /** 获取所有适配器类型 */
+    getAdapterTypes() {
+        return (0, index_1.listAdapterTypes)();
+    }
+    /** 获取数据源类型信息（前端向导展示用） */
+    getDataSourceTypeInfos() {
+        return (0, index_1.getDataSourceTypeInfos)();
+    }
+    /** 获取指定类型的信息 */
+    getDataSourceTypeInfo(type) {
+        return (0, index_1.getDataSourceTypeInfo)(type);
+    }
+    // ===================== 目录式连接器包管理 =====================
+    /** 自动发现连接器：扫描 data/connectors/ 目录，为每个有 manifest.json 的目录构建连接器实体 */
+    async autoDiscoverConnectors() {
+        if (!fs.existsSync(CONNECTORS_DIR)) {
+            fs.mkdirSync(CONNECTORS_DIR, { recursive: true });
+            connectorCache = [];
+            return;
+        }
+        const newCache = [];
+        connectorDirMap.clear();
+        for (const dirName of fs.readdirSync(CONNECTORS_DIR)) {
+            const manifestPath = path.join(CONNECTORS_DIR, dirName, 'manifest.json');
+            if (!fs.existsSync(manifestPath))
+                continue;
+            try {
+                const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+                const packageDir = path.join(CONNECTORS_DIR, dirName);
+                const connector = this.buildConnectorFromManifest(dirName, manifest, packageDir);
+                connectorDirMap.set(connector.id, dirName);
+                newCache.push(connector);
+                console.log(`[ConnectorService] Discovered: ${manifest.name} (${connector.mcpServerIds.length} MCP, ${connector.skillIds.length} skills, enabled=${connector.enabled})`);
+            }
+            catch (e) {
+                console.warn(`[ConnectorService] Failed to load ${dirName}:`, e?.message);
+            }
+        }
+        connectorCache = newCache;
+        console.log(`[ConnectorService] Auto-discovery complete: ${connectorCache.length} connectors`);
+    }
+    /** 从 manifest 构建连接器实体 */
+    buildConnectorFromManifest(dirName, manifest, packageDir) {
+        const id = dirName;
+        const now = new Date().toISOString();
+        const enabled = manifest.enabled !== false;
+        // 扫描 mcp-servers/ 目录获取 MCP 服务器 ID 列表
+        const mcpServerIds = [];
+        const mcpServersDir = path.join(packageDir, 'mcp-servers');
+        if (enabled && fs.existsSync(mcpServersDir)) {
+            for (const file of fs.readdirSync(mcpServersDir)) {
+                if (!file.endsWith('.json'))
+                    continue;
+                try {
+                    const serverConfig = JSON.parse(fs.readFileSync(path.join(mcpServersDir, file), 'utf-8'));
+                    mcpServerIds.push(serverConfig.id || path.basename(file, '.json'));
+                }
+                catch { /* skip */ }
+            }
+        }
+        // 扫描 skills/ 目录获取 Skill ID 列表
+        const skillIds = [];
+        const skillsDir = path.join(packageDir, 'skills');
+        if (fs.existsSync(skillsDir)) {
+            for (const file of fs.readdirSync(skillsDir)) {
+                if (file.endsWith('.md')) {
+                    skillIds.push(path.basename(file, '.md'));
+                }
+            }
+        }
+        return {
+            id,
+            name: manifest.name,
+            description: manifest.description,
+            icon: manifest.icon,
+            color: manifest.color,
+            category: manifest.category || 'data',
+            version: manifest.version,
+            author: manifest.author,
+            mcpServerIds,
+            skillIds,
+            enabled,
+            status: 'installed',
+            dataSourceType: manifest.dataSourceType,
+            dataSourceConfig: manifest.dataSourceConfig,
+            createdAt: now,
+            updatedAt: now,
+        };
+    }
+    /** 列出所有目录式连接器实体 */
+    listConnectorEntities() {
+        return [...connectorCache];
+    }
+    /** 获取单个目录式连接器实体 */
+    getConnectorEntity(id) {
+        return connectorCache.find(c => c.id === id);
+    }
+    /** 获取连接器包目录（校验存在性） */
+    getConnectorPackageDir(connectorId) {
+        const dirName = connectorDirMap.get(connectorId);
+        if (!dirName)
+            throw new Error(`连接器不存在: ${connectorId}`);
+        return path.join(CONNECTORS_DIR, dirName);
+    }
+    /** 读取 manifest.json */
+    getManifest(connectorId) {
+        const dirName = connectorDirMap.get(connectorId);
+        if (!dirName)
+            throw new Error(`连接器不存在: ${connectorId}`);
+        const manifestPath = path.join(CONNECTORS_DIR, dirName, 'manifest.json');
+        if (!fs.existsSync(manifestPath))
+            throw new Error(`manifest.json 不存在: ${dirName}`);
+        return JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+    }
+    /** 更新 manifest.json */
+    updateManifest(connectorId, updates) {
+        const dirName = connectorDirMap.get(connectorId);
+        if (!dirName)
+            throw new Error(`连接器不存在: ${connectorId}`);
+        const manifestPath = path.join(CONNECTORS_DIR, dirName, 'manifest.json');
+        const manifest = this.getManifest(connectorId);
+        const updated = { ...manifest, ...updates };
+        fs.writeFileSync(manifestPath, JSON.stringify(updated, null, 2), 'utf-8');
+        return updated;
+    }
+    /** 启用/禁用连接器，回写 manifest.json */
+    toggleConnector(id, enabled) {
+        const connector = connectorCache.find(c => c.id === id);
+        if (!connector)
+            return undefined;
+        if (connector.enabled === enabled)
+            return { ...connector };
+        connector.enabled = enabled;
+        connector.updatedAt = new Date().toISOString();
+        // 回写 manifest.json
+        const dirName = connectorDirMap.get(connector.id);
+        if (dirName) {
+            const manifest = this.getManifest(connector.id);
+            manifest.enabled = enabled;
+            const manifestPath = path.join(CONNECTORS_DIR, dirName, 'manifest.json');
+            fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+        }
+        if (enabled) {
+            // 启用：重新扫描 MCP/Skills
+            const packageDir = this.getConnectorPackageDir(connector.id);
+            const manifest = this.getManifest(connector.id);
+            connector.mcpServerIds = [];
+            const mcpServersDir = path.join(packageDir, 'mcp-servers');
+            if (fs.existsSync(mcpServersDir)) {
+                for (const file of fs.readdirSync(mcpServersDir)) {
+                    if (!file.endsWith('.json'))
+                        continue;
+                    try {
+                        const serverConfig = JSON.parse(fs.readFileSync(path.join(mcpServersDir, file), 'utf-8'));
+                        connector.mcpServerIds.push(serverConfig.id || path.basename(file, '.json'));
+                    }
+                    catch { /* skip */ }
+                }
+            }
+            console.log(`[ConnectorService] Enabled: ${connector.name}`);
+        }
+        else {
+            // 禁用：清理 MCP 引用
+            connector.mcpServerIds = [];
+            console.log(`[ConnectorService] Disabled: ${connector.name}`);
+        }
+        return { ...connector };
+    }
+    /** 重新生成连接器：重新调用适配器发现工具，清空并重写 mcp-servers/*.json */
+    async regenerateConnector(connectorId) {
+        const dirName = connectorDirMap.get(connectorId);
+        if (!dirName)
+            throw new Error(`连接器不存在: ${connectorId}`);
+        const packageDir = path.join(CONNECTORS_DIR, dirName);
+        const manifest = this.getManifest(connectorId);
+        const dsType = manifest.dataSourceType;
+        const dsConfig = manifest.dataSourceConfig;
+        if (!dsType || !dsConfig) {
+            throw new Error('此连接器无数据源配置，无法重新生成');
+        }
+        // 调用适配器重新发现工具
+        const adapter = (0, index_1.getAdapter)(dsType);
+        const resolvedDsConfig = (0, agent_server_1.expandEnvVars)(dsConfig);
+        const config = { type: dsType, name: manifest.name, ...resolvedDsConfig, enabled: true };
+        const tools = await adapter.discoverTools(config);
+        // 清空并重写 mcp-servers/*.json
+        const mcpDir = path.join(packageDir, 'mcp-servers');
+        if (fs.existsSync(mcpDir)) {
+            for (const file of fs.readdirSync(mcpDir)) {
+                if (file.endsWith('.json')) {
+                    fs.unlinkSync(path.join(mcpDir, file));
+                }
+            }
+        }
+        else {
+            fs.mkdirSync(mcpDir, { recursive: true });
+        }
+        // 生成并写入新的 MCP 服务器配置
+        const mcpConfigs = await adapter.generateMCPServerConfigs(config);
+        for (const mcpConfig of mcpConfigs) {
+            const fileName = mcpConfig.name.replace(/[^a-zA-Z0-9_-]/g, '_');
+            const serverConfig = {
+                name: mcpConfig.name,
+                transport: mcpConfig.transport,
+                command: mcpConfig.command,
+                args: mcpConfig.args,
+                env: mcpConfig.env,
+                url: mcpConfig.url,
+                toolDefinitions: mcpConfig.tools.map(t => ({
+                    name: t.name,
+                    description: t.description,
+                    parameters: t.inputSchema,
+                })),
+            };
+            fs.writeFileSync(path.join(mcpDir, `${fileName}.json`), JSON.stringify(serverConfig, null, 2), 'utf-8');
+        }
+        console.log(`[ConnectorService] Regenerated: ${dirName} (${tools.length} tools)`);
+        // 重新加载连接器
+        await this.autoDiscoverConnectors();
+        const connector = connectorCache.find(c => c.id === connectorId);
+        if (!connector)
+            throw new Error(`连接器重新生成后未找到: ${connectorId}`);
+        return { toolCount: tools.length, connector };
+    }
+    // ===================== MCP Server 文件 CRUD =====================
+    /** 新增 MCP 服务器配置文件 */
+    async addConnectorMCPServer(connectorId, config) {
+        const packageDir = this.getConnectorPackageDir(connectorId);
+        const name = config.name || 'new-server';
+        const fileName = name.replace(/[^a-zA-Z0-9_-]/g, '_');
+        const mcpDir = path.join(packageDir, 'mcp-servers');
+        const filePath = path.join(mcpDir, `${fileName}.json`);
+        if (!fs.existsSync(mcpDir))
+            fs.mkdirSync(mcpDir, { recursive: true });
+        if (fs.existsSync(filePath))
+            throw new Error(`MCP 服务器配置已存在: ${fileName}`);
+        fs.writeFileSync(filePath, JSON.stringify(config, null, 2), 'utf-8');
+        await this.autoDiscoverConnectors();
+        return { serverName: fileName };
+    }
+    /** 更新 MCP 服务器配置文件 */
+    async updateConnectorMCPServer(connectorId, serverName, config) {
+        const packageDir = this.getConnectorPackageDir(connectorId);
+        const fileName = serverName.replace(/[^a-zA-Z0-9_-]/g, '_');
+        const filePath = path.join(packageDir, 'mcp-servers', `${fileName}.json`);
+        if (!fs.existsSync(filePath))
+            throw new Error(`MCP 服务器配置不存在: ${fileName}`);
+        fs.writeFileSync(filePath, JSON.stringify(config, null, 2), 'utf-8');
+        await this.autoDiscoverConnectors();
+    }
+    /** 删除 MCP 服务器配置文件 */
+    async removeConnectorMCPServer(connectorId, serverName) {
+        const packageDir = this.getConnectorPackageDir(connectorId);
+        const fileName = serverName.replace(/[^a-zA-Z0-9_-]/g, '_');
+        const filePath = path.join(packageDir, 'mcp-servers', `${fileName}.json`);
+        if (!fs.existsSync(filePath))
+            throw new Error(`MCP 服务器配置不存在: ${fileName}`);
+        fs.unlinkSync(filePath);
+        await this.autoDiscoverConnectors();
+    }
+    // ===================== Skill 文件 CRUD =====================
+    /** 读取 Skill .md 文件完整内容 */
+    getConnectorSkillFile(connectorId, skillId) {
+        const packageDir = this.getConnectorPackageDir(connectorId);
+        const filePath = path.join(packageDir, 'skills', `${skillId}.md`);
+        if (!fs.existsSync(filePath))
+            throw new Error(`Skill 文件不存在: ${skillId}`);
+        return { content: fs.readFileSync(filePath, 'utf-8') };
+    }
+    /** 新建 Skill .md 文件 */
+    async addConnectorSkill(connectorId, skillId, content) {
+        const packageDir = this.getConnectorPackageDir(connectorId);
+        const safeId = skillId.replace(/[^a-zA-Z0-9_-]/g, '-');
+        const skillsDir = path.join(packageDir, 'skills');
+        const filePath = path.join(skillsDir, `${safeId}.md`);
+        if (!fs.existsSync(skillsDir))
+            fs.mkdirSync(skillsDir, { recursive: true });
+        if (fs.existsSync(filePath))
+            throw new Error(`Skill 已存在: ${safeId}`);
+        fs.writeFileSync(filePath, content, 'utf-8');
+        await this.autoDiscoverConnectors();
+    }
+    /** 更新 Skill .md 文件 */
+    async updateConnectorSkill(connectorId, skillId, content) {
+        const packageDir = this.getConnectorPackageDir(connectorId);
+        const filePath = path.join(packageDir, 'skills', `${skillId}.md`);
+        if (!fs.existsSync(filePath))
+            throw new Error(`Skill 文件不存在: ${skillId}`);
+        fs.writeFileSync(filePath, content, 'utf-8');
+        await this.autoDiscoverConnectors();
+    }
+    /** 删除 Skill .md 文件 */
+    async removeConnectorSkill(connectorId, skillId) {
+        const packageDir = this.getConnectorPackageDir(connectorId);
+        const filePath = path.join(packageDir, 'skills', `${skillId}.md`);
+        if (!fs.existsSync(filePath))
+            throw new Error(`Skill 文件不存在: ${skillId}`);
+        fs.unlinkSync(filePath);
+        await this.autoDiscoverConnectors();
+    }
+    // ===================== 私有方法 =====================
+    getFilePath(id) {
+        return path.join(CONNECTORS_DIR, `${id}.json`);
+    }
+    generateId(name) {
+        const slug = (name || 'connector')
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-|-$/g, '');
+        return `${slug}-${Date.now().toString(36)}`;
+    }
+    async ensureDir() {
+        await fsp.mkdir(CONNECTORS_DIR, { recursive: true });
+    }
+};
+exports.ConnectorService = ConnectorService;
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], ConnectorService.prototype, "init", null);
+exports.ConnectorService = ConnectorService = __decorate([
+    (0, core_1.Provide)()
+], ConnectorService);

package/dist/service/knowledge-base.service.d.ts

@@ -0,0 +1,138 @@
+import { BaseService } from '@cicctencent/midwayjs-base';
+import { DataSource, Repository } from 'typeorm';
+import { OpenAIService } from './openai.service';
+import AIKnowledgeBaseEntity from '../model/ai-knowledge-base.entity';
+import AIKBDocumentEntity from '../model/ai-kb-document.entity';
+import type { EmbeddingProvider } from '@cicctencent/agent-core';
+/**
+ * 文档分块
+ */
+export interface DocumentChunk {
+    id: string;
+    documentId: number;
+    content: string;
+    embedding: number[];
+    metadata: Record<string, any>;
+}
+/**
+ * 搜索选项
+ */
+export interface SearchOptions {
+    topK?: number;
+    scoreThreshold?: number;
+}
+/**
+ * 知识库服务
+ * 管理知识库的创建、文档索引、向量搜索
+ *
+ * 向量存储委托给 agent-server 的 FileKnowledgeBase，
+ * 元数据（KnowledgeBase / KBDocument）仍由 TypeORM 实体管理。
+ */
+export declare class KnowledgeBaseService extends BaseService {
+    dataSource: DataSource;
+    openaiService: OpenAIService;
+    openaiConfig: any;
+    private kbRepo?;
+    private docRepo?;
+    /** FileKnowledgeBase 实例缓存: Map<knowledgeBaseId, FileKnowledgeBase> */
+    private kbInstances;
+    /** EmbeddingProvider 实例（懒加载） */
+    private _embeddingProvider?;
+    get kbModel(): Repository<AIKnowledgeBaseEntity>;
+    get docModel(): Repository<AIKBDocumentEntity>;
+    /**
+     * 获取 EmbeddingProvider，使用 OpenAIService 生成 embedding
+     */
+    getEmbeddingProvider(): EmbeddingProvider;
+    /**
+     * 获取或创建 FileKnowledgeBase 实例
+     * 每个 KnowledgeBase 对应一个 FileKnowledgeBase（通过 docId 前缀隔离）
+     */
+    private getFileKB;
+    /** 列出知识库 */
+    list(applicationId: number, options?: {
+        enabled?: boolean;
+        status?: string;
+    }): Promise<AIKnowledgeBaseEntity[]>;
+    /** 获取单个知识库 */
+    get(id: number, applicationId?: number): Promise<AIKnowledgeBaseEntity>;
+    /** 创建知识库 */
+    create(applicationId: number, data: Partial<AIKnowledgeBaseEntity>): Promise<AIKnowledgeBaseEntity>;
+    /** 更新知识库 */
+    update(id: number, applicationId: number, data: Partial<AIKnowledgeBaseEntity>): Promise<AIKnowledgeBaseEntity>;
+    /** 删除知识库 */
+    delete(id: number, applicationId: number): Promise<void>;
+    /** 启用知识库 */
+    enable(id: number, applicationId: number): Promise<AIKnowledgeBaseEntity>;
+    /** 禁用知识库 */
+    disable(id: number, applicationId: number): Promise<AIKnowledgeBaseEntity>;
+    /** 获取文档列表 */
+    getDocuments(knowledgeBaseId: number): Promise<AIKBDocumentEntity[]>;
+    /** 删除文档 */
+    deleteDocument(documentId: number): Promise<void>;
+    /**
+     * 从文件索引文档
+     * 使用 agent-server 的 parseDocument() 解析文件 + FileKnowledgeBase.ingest() 存储
+     *
+     * @param id 知识库 ID
+     * @param filePath 文件路径
+     * @param title 文档标题（可选，默认使用文件名）
+     */
+    indexFromFile(id: number, filePath: string, title?: string): Promise<{
+        documentId: number;
+        chunkCount: number;
+    }>;
+    /**
+     * 索引文档
+     * 对于有 sourcePath 的文档使用 parseDocument() 解析，否则使用内置分块逻辑
+     * 所有分块通过 FileKnowledgeBase.ingest() 存储
+     */
+    indexDocuments(id: number, documents: Array<{
+        title: string;
+        content: string;
+        sourcePath?: string;
+        sourceType?: string;
+        meta?: Record<string, any>;
+    }>): Promise<{
+        documentCount: number;
+        chunkCount: number;
+    }>;
+    /**
+     * 重新索引
+     */
+    reindex(id: number): Promise<{
+        documentCount: number;
+        chunkCount: number;
+    }>;
+    /**
+     * 向量搜索
+     * 使用 FileKnowledgeBase.search(query, topK) 进行语义检索
+     */
+    search(id: number, query: string, options?: SearchOptions): Promise<Array<{
+        content: string;
+        score: number;
+        metadata: Record<string, any>;
+    }>>;
+    /**
+     * 使用 EmbeddingVectorIndex 进行向量搜索
+     * 适用于需要自定义向量索引的场景
+     *
+     * @param id 知识库 ID
+     * @param query 查询文本
+     * @param topK 返回结果数
+     */
+    searchWithVectorIndex(id: number, query: string, topK?: number): Promise<Array<{
+        content: string;
+        score: number;
+        metadata: Record<string, any>;
+    }>>;
+    /**
+     * 使用配置参数对文本进行分块
+     * 参考 agent-server parseDocument 的 chunkText 逻辑
+     */
+    private chunkTextWithConfig;
+    /**
+     * 哈希向量（降级方案）
+     */
+    private hashEmbedding;
+}