blade-ai/dist/index.d.ts

🗡️ Blade - 智能 AI 助手命令行工具

import { EventEmitter } from 'events';

/**
 * 上下文管理模块的核心类型定义
 */
interface ContextMessage {
    id: string;
    role: 'user' | 'assistant' | 'system' | 'tool';
    content: string;
    timestamp: number;
    metadata?: Record<string, any>;
}
interface ToolCall {
    id: string;
    name: string;
    input: any;
    output?: any;
    timestamp: number;
    status: 'pending' | 'success' | 'error';
    error?: string;
}
interface SystemContext {
    role: string;
    capabilities: string[];
    tools: string[];
    version: string;
}
interface SessionContext {
    sessionId: string;
    userId?: string;
    preferences: Record<string, any>;
    configuration: Record<string, any>;
    startTime: number;
}
interface ConversationContext {
    messages: ContextMessage[];
    summary?: string;
    topics: string[];
    lastActivity: number;
}
interface ToolContext {
    recentCalls: ToolCall[];
    toolStates: Record<string, any>;
    dependencies: Record<string, string[]>;
}
interface WorkspaceContext {
    projectPath?: string;
    currentFiles: string[];
    recentFiles: string[];
    gitInfo?: {
        branch: string;
        status: string;
        lastCommit?: string;
    };
    environment: Record<string, any>;
}
interface ContextLayer {
    system: SystemContext;
    session: SessionContext;
    conversation: ConversationContext;
    tool: ToolContext;
    workspace: WorkspaceContext;
}
interface ContextData {
    layers: ContextLayer;
    metadata: {
        totalTokens: number;
        priority: number;
        relevanceScore?: number;
        lastUpdated: number;
    };
}
interface ContextFilter {
    maxTokens?: number;
    maxMessages?: number;
    timeWindow?: number;
    priority?: number;
    includeTools?: boolean;
    includeWorkspace?: boolean;
}
interface CompressedContext {
    summary: string;
    keyPoints: string[];
    recentMessages: ContextMessage[];
    toolSummary?: string;
    tokenCount: number;
}
interface ContextStorageOptions {
    maxMemorySize: number;
    persistentPath?: string;
    cacheSize: number;
    compressionEnabled: boolean;
}
interface ContextManagerOptions {
    storage: ContextStorageOptions;
    defaultFilter: ContextFilter;
    compressionThreshold: number;
    enableVectorSearch?: boolean;
}

/**
 * 上下文管理器 - 统一管理所有上下文相关操作
 */
declare class ContextManager {
    private readonly memory;
    private readonly persistent;
    private readonly cache;
    private readonly compressor;
    private readonly filter;
    private readonly options;
    private currentSessionId;
    private initialized;
    constructor(options?: Partial<ContextManagerOptions>);
    /**
     * 初始化上下文管理器
     */
    initialize(): Promise<void>;
    /**
     * 创建新会话
     */
    createSession(userId?: string, preferences?: Record<string, any>, configuration?: Record<string, any>): Promise<string>;
    /**
     * 加载现有会话
     */
    loadSession(sessionId: string): Promise<boolean>;
    /**
     * 添加消息到当前会话
     */
    addMessage(role: ContextMessage['role'], content: string, metadata?: Record<string, any>): Promise<void>;
    /**
     * 添加工具调用记录
     */
    addToolCall(toolCall: ToolCall): Promise<void>;
    /**
     * 更新工具状态
     */
    updateToolState(toolName: string, state: any): void;
    /**
     * 更新工作空间信息
     */
    updateWorkspace(updates: Partial<WorkspaceContext>): void;
    /**
     * 获取格式化的上下文用于 Prompt 构建
     */
    getFormattedContext(filterOptions?: ContextFilter): Promise<{
        context: ContextData;
        compressed?: CompressedContext;
        tokenCount: number;
    }>;
    /**
     * 搜索历史会话
     */
    searchSessions(query: string, limit?: number): Promise<Array<{
        sessionId: string;
        summary: string;
        lastActivity: number;
        relevanceScore: number;
    }>>;
    /**
     * 获取缓存的工具调用结果
     */
    getCachedToolResult(toolName: string, input: any): any;
    /**
     * 获取管理器统计信息
     */
    getStats(): Promise<{
        currentSession: string | null;
        memory: any;
        cache: any;
        storage: any;
    }>;
    /**
     * 清理资源
     */
    cleanup(): Promise<void>;
    private generateSessionId;
    private generateMessageId;
    private createSystemContext;
    private createWorkspaceContext;
    private shouldCompress;
    private compressCurrentContext;
    private saveCurrentSession;
    private saveCurrentSessionAsync;
    private hashContext;
    private calculateRelevance;
}

/**
 * 组件基类
 * 提供组件的基本实现，可被具体组件继承
 */
declare abstract class BaseComponent {
    protected id: string;
    constructor(id: string);
    /**
     * 获取组件ID
     */
    getId(): string;
    /**
     * 获取组件名称（兼容性方法）
     */
    get name(): string;
    /**
     * 初始化组件
     * 子类应重写此方法实现具体的初始化逻辑
     */
    init(): Promise<void>;
    /**
     * 销毁组件
     * 子类应重写此方法实现具体的销毁逻辑
     */
    destroy(): Promise<void>;
}

/**
 * LLM 消息接口
 */
interface LLMMessage {
    role: 'system' | 'user' | 'assistant';
    content: string;
}
/**
 * LLM 请求参数
 */
interface LLMRequest {
    messages: LLMMessage[];
    model?: string;
    temperature?: number;
    maxTokens?: number;
    stream?: boolean;
}
/**
 * LLM 响应接口
 */
interface LLMResponse {
    content: string;
    usage?: {
        promptTokens: number;
        completionTokens: number;
        totalTokens: number;
    };
    model?: string;
}
/**
 * 重试配置
 */
interface RetryConfig {
    maxRetries: number;
    baseDelay: number;
    maxDelay: number;
    backoffFactor: number;
}
/**
 * 基础 LLM 组件类
 */
declare abstract class BaseLLM extends BaseComponent {
    protected retryConfig: RetryConfig;
    protected defaultModel: string;
    constructor(name: string, defaultModel?: string);
    /**
     * 设置重试配置
     */
    setRetryConfig(config: Partial<RetryConfig>): void;
    /**
     * 抽象方法：发送请求到 LLM 服务
     */
    protected abstract sendRequest(request: LLMRequest): Promise<LLMResponse>;
    /**
     * 公共方法：带重试机制的聊天
     */
    chat(request: LLMRequest): Promise<LLMResponse>;
    /**
     * 便捷方法：发送单条消息
     */
    sendMessage(content: string, role?: 'user' | 'system', options?: Partial<LLMRequest>): Promise<string>;
    /**
     * 便捷方法：多轮对话
     */
    conversation(messages: LLMMessage[], options?: Partial<LLMRequest>): Promise<string>;
    /**
     * 重试机制实现
     */
    protected withRetry<T>(operation: () => Promise<T>): Promise<T>;
    /**
     * 判断是否应该重试
     */
    protected shouldRetry(error: Error): boolean;
    /**
     * 计算延迟时间（指数退避）
     */
    protected calculateDelay(attempt: number): number;
    /**
     * 睡眠函数
     */
    protected sleep(ms: number): Promise<void>;
    /**
     * 验证请求参数
     */
    protected validateRequest(request: LLMRequest): void;
}

/**
 * 工具参数模式定义
 */
interface ToolParameterSchema {
    type: 'string' | 'number' | 'boolean' | 'array' | 'object';
    description?: string;
    required?: boolean;
    default?: any;
    enum?: any[];
    items?: ToolParameterSchema;
    properties?: Record<string, ToolParameterSchema>;
}
/**
 * 工具定义接口
 */
interface ToolDefinition {
    /** 工具名称 */
    name: string;
    /** 工具描述 */
    description: string;
    /** 工具版本 */
    version?: string;
    /** 工具作者 */
    author?: string;
    /** 工具分类 */
    category?: string;
    /** 工具标签 */
    tags?: string[];
    /** 参数模式定义 */
    parameters: Record<string, ToolParameterSchema>;
    /** 必需参数列表 */
    required?: string[];
    /** 输入模式定义 */
    inputSchema?: {
        type?: string;
        properties?: Record<string, any>;
        required?: string[];
    };
    /** 输出模式定义 */
    outputSchema?: any;
    /** 使用示例 */
    examples?: any[];
    /** 工具执行函数 */
    execute: (params: Record<string, any>) => Promise<ToolExecutionResult>;
}
/**
 * 工具执行结果
 */
interface ToolExecutionResult {
    /** 执行是否成功 */
    success: boolean;
    /** 返回数据 */
    data?: any;
    /** 错误信息 */
    error?: string;
    /** 执行时间（毫秒） */
    duration?: number;
    /** 额外元数据 */
    metadata?: Record<string, any>;
}
/**
 * 工具执行上下文
 */
interface ToolExecutionContext {
    /** 执行ID */
    executionId: string;
    /** 执行时间戳 */
    timestamp: number;
    /** 用户ID */
    userId?: string;
    /** 会话ID */
    sessionId?: string;
    /** 额外上下文数据 */
    context?: Record<string, any>;
}
/**
 * 工具注册选项
 */
interface ToolRegistrationOptions {
    /** 是否覆盖已存在的工具 */
    override?: boolean;
    /** 工具启用状态 */
    enabled?: boolean;
    /** 工具权限配置 */
    permissions?: string[];
}
/**
 * 工具调用请求
 */
interface ToolCallRequest {
    /** 工具名称 */
    toolName: string;
    /** 调用参数 */
    parameters: Record<string, any>;
    /** 执行上下文 */
    context?: ToolExecutionContext;
}
/**
 * 工具调用响应
 */
interface ToolCallResponse {
    /** 请求ID */
    requestId: string;
    /** 工具名称 */
    toolName: string;
    /** 执行结果 */
    result: ToolExecutionResult;
    /** 执行上下文 */
    context: ToolExecutionContext;
}
/**
 * 工具管理器配置
 */
interface ToolManagerConfig {
    /** 是否启用调试模式 */
    debug?: boolean;
    /** 最大并发执行数 */
    maxConcurrency?: number;
    /** 执行超时时间（毫秒） */
    executionTimeout?: number;
    /** 是否记录执行历史 */
    logHistory?: boolean;
    /** 历史记录最大数量 */
    maxHistorySize?: number;
}
/**
 * 工具执行历史记录
 */
interface ToolExecutionHistory {
    /** 执行ID */
    executionId: string;
    /** 工具名称 */
    toolName: string;
    /** 执行参数 */
    parameters: Record<string, any>;
    /** 执行结果 */
    result: ToolExecutionResult;
    /** 执行上下文 */
    context: ToolExecutionContext;
    /** 创建时间 */
    createdAt: Date;
}
/**
 * 工具验证错误
 */
declare class ToolValidationError extends Error {
    readonly field?: string | undefined;
    readonly value?: any | undefined;
    constructor(message: string, field?: string | undefined, value?: any | undefined);
}
/**
 * 工具执行错误
 */
declare class ToolExecutionError extends Error {
    readonly toolName: string;
    readonly originalError?: Error | undefined;
    constructor(message: string, toolName: string, originalError?: Error | undefined);
}
/**
 * 工具注册错误
 */
declare class ToolRegistrationError extends Error {
    readonly toolName?: string | undefined;
    constructor(message: string, toolName?: string | undefined);
}

/**
 * 工具管理器 - 负责工具的注册、管理和调用
 */
declare class ToolManager extends EventEmitter {
    private tools;
    private toolStates;
    private executionHistory;
    private runningExecutions;
    private config;
    constructor(config?: ToolManagerConfig);
    /**
     * 注册工具
     */
    registerTool(tool: ToolDefinition, options?: ToolRegistrationOptions): Promise<void>;
    /**
     * 注销工具
     */
    unregisterTool(toolName: string): boolean;
    /**
     * 获取所有已注册的工具
     */
    getTools(): ToolDefinition[];
    /**
     * 获取特定工具
     */
    getTool(toolName: string): ToolDefinition | undefined;
    /**
     * 检查工具是否存在
     */
    hasTool(toolName: string): boolean;
    /**
     * 启用/禁用工具
     */
    setToolEnabled(toolName: string, enabled: boolean): void;
    /**
     * 检查工具是否启用
     */
    isToolEnabled(toolName: string): boolean;
    /**
     * 调用工具
     */
    callTool(request: ToolCallRequest): Promise<ToolCallResponse>;
    /**
     * 获取执行历史
     */
    getExecutionHistory(limit?: number): ToolExecutionHistory[];
    /**
     * 清空执行历史
     */
    clearHistory(): void;
    /**
     * 获取工具统计信息
     */
    getStats(): Record<string, any>;
    /**
     * 验证工具定义
     */
    private validateToolDefinition;
    /**
     * 执行工具并设置超时
     */
    private executeToolWithTimeout;
    /**
     * 添加到历史记录
     */
    private addToHistory;
    /**
     * 日志记录
     */
    private log;
}

/**
 * 工具参数验证器
 */
declare class ToolValidator {
    /**
     * 验证工具参数
     */
    static validateParameters(parameters: Record<string, any>, schema: Record<string, ToolParameterSchema>, required?: string[]): void;
    /**
     * 验证单个值
     */
    private static validateValue;
    /**
     * 检查值类型是否匹配
     */
    private static isValidType;
    /**
     * 应用默认值
     */
    static applyDefaults(parameters: Record<string, any>, schema: Record<string, ToolParameterSchema>): Record<string, any>;
    /**
     * 清理参数（移除未定义的参数）
     */
    static sanitizeParameters(parameters: Record<string, any>, schema: Record<string, ToolParameterSchema>): Record<string, any>;
    /**
     * 生成参数文档
     */
    static generateDocumentation(schema: Record<string, ToolParameterSchema>, required?: string[]): string;
}

/**
 * 导出所有文件系统工具
 */
declare const fileSystemTools: ToolDefinition[];

/**
 * Git 工具集合
 * 提供完整的Git操作功能
 */
declare const gitTools: ToolDefinition[];

/**
 * 导出所有网络工具
 */
declare const networkTools: ToolDefinition[];

/**
 * 智能工具集合
 * 基于LLM增强的高级功能工具
 */
declare const smartTools: ToolDefinition[];

/**
 * 导出所有文本处理工具
 */
declare const textProcessingTools: ToolDefinition[];

/**
 * 导出所有实用工具
 */
declare const utilityTools: ToolDefinition[];

/**
 * 创建工具管理器并注册内置工具
 */
declare function createToolManager(config?: ToolManagerConfig, includeBuiltinTools?: boolean): Promise<ToolManager>;
/**
 * 按分类获取内置工具
 */
declare function getBuiltinToolsByCategory(): Record<string, ToolDefinition[]>;
/**
 * 获取所有内置工具
 */
declare function getAllBuiltinTools(): ToolDefinition[];

/**
 * 组件管理器配置
 */
interface ComponentManagerConfig {
    debug?: boolean;
    autoInit?: boolean;
}
/**
 * 组件管理器
 * 负责管理所有组件的生命周期和状态
 */
declare class ComponentManager extends EventEmitter {
    private components;
    private config;
    private isInitialized;
    private isDestroyed;
    constructor(config?: ComponentManagerConfig);
    /**
     * 初始化所有组件
     */
    init(): Promise<void>;
    /**
     * 销毁所有组件
     */
    destroy(): Promise<void>;
    /**
     * 注册组件
     */
    registerComponent(component: BaseComponent): Promise<void>;
    /**
     * 获取组件
     */
    getComponent<T extends BaseComponent>(id: string): T | undefined;
    /**
     * 检查组件是否存在
     */
    hasComponent(id: string): boolean;
    /**
     * 移除组件
     */
    removeComponent(id: string): Promise<boolean>;
    /**
     * 获取所有组件ID
     */
    getComponentIds(): string[];
    /**
     * 获取所有组件
     */
    getAllComponents(): Map<string, BaseComponent>;
    /**
     * 按类型获取组件
     */
    getComponentsByType<T extends BaseComponent>(componentClass: new (...args: any[]) => T): T[];
    /**
     * 搜索组件
     */
    searchComponents(predicate: (component: BaseComponent) => boolean): BaseComponent[];
    /**
     * 批量注册组件
     */
    registerComponents(components: BaseComponent[]): Promise<void>;
    /**
     * 批量移除组件
     */
    removeComponents(ids: string[]): Promise<{
        [id: string]: boolean;
    }>;
    /**
     * 重启组件
     */
    restartComponent(id: string): Promise<boolean>;
    /**
     * 获取组件状态
     */
    getComponentStatus(id: string): {
        exists: boolean;
        initialized: boolean;
        component?: BaseComponent;
    };
    /**
     * 获取管理器状态
     */
    getStatus(): {
        isInitialized: boolean;
        isDestroyed: boolean;
        componentCount: number;
        componentIds: string[];
        config: ComponentManagerConfig;
    };
    /**
     * 获取健康状态
     */
    getHealthStatus(): Promise<{
        healthy: boolean;
        components: {
            [id: string]: {
                healthy: boolean;
                error?: string;
            };
        };
    }>;
    /**
     * 等待组件初始化完成
     */
    waitForInitialization(timeout?: number): Promise<void>;
    /**
     * 日志记录
     */
    private log;
}

/**
 * 上下文组件配置
 */
interface ContextComponentConfig {
    debug?: boolean;
    enabled?: boolean;
    storage?: {
        maxMemorySize?: number;
        persistentPath?: string;
        cacheSize?: number;
        compressionEnabled?: boolean;
    };
    defaultFilter?: {
        maxTokens?: number;
        maxMessages?: number;
        timeWindow?: number;
        includeTools?: boolean;
        includeWorkspace?: boolean;
    };
    compressionThreshold?: number;
    enableVectorSearch?: boolean;
}
/**
 * 上下文组件 - 管理对话历史、工具调用记录和工作空间状态
 */
declare class ContextComponent extends BaseComponent {
    private contextManager?;
    private config;
    private currentSessionId?;
    private isReady;
    constructor(id?: string, config?: ContextComponentConfig);
    /**
     * 初始化上下文组件
     */
    init(): Promise<void>;
    /**
     * 销毁上下文组件
     */
    destroy(): Promise<void>;
    /**
     * 创建新会话
     */
    createSession(userId?: string, preferences?: Record<string, any>, configuration?: Record<string, any>, customSessionId?: string): Promise<string>;
    /**
     * 加载现有会话
     */
    loadSession(sessionId: string): Promise<boolean>;
    /**
     * 获取当前会话ID
     */
    getCurrentSessionId(): string | undefined;
    /**
     * 添加用户消息
     */
    addUserMessage(content: string, metadata?: Record<string, any>): Promise<void>;
    /**
     * 添加助手消息
     */
    addAssistantMessage(content: string, metadata?: Record<string, any>): Promise<void>;
    /**
     * 添加系统消息
     */
    addSystemMessage(content: string, metadata?: Record<string, any>): Promise<void>;
    /**
     * 添加工具调用记录
     */
    addToolCall(toolCall: ToolCall): Promise<void>;
    /**
     * 更新工具状态
     */
    updateToolState(toolName: string, state: any): void;
    /**
     * 更新工作空间信息
     */
    updateWorkspace(updates: Partial<WorkspaceContext>): void;
    /**
     * 获取格式化的上下文
     */
    getFormattedContext(filterOptions?: ContextFilter): Promise<{
        context: ContextData;
        compressed?: CompressedContext;
        tokenCount: number;
    }>;
    /**
     * 获取上下文为Prompt字符串
     */
    getContextForPrompt(filterOptions?: ContextFilter, formatOptions?: {
        includeSystemInfo?: boolean;
        includeToolHistory?: boolean;
        includeWorkspaceInfo?: boolean;
        maxRecentMessages?: number;
    }): Promise<string>;
    /**
     * 搜索历史会话
     */
    searchSessions(query: string, limit?: number): Promise<Array<{
        sessionId: string;
        summary: string;
        lastActivity: number;
        relevanceScore: number;
    }>>;
    /**
     * 获取缓存的工具调用结果
     */
    getCachedToolResult(toolName: string, input: any): any;
    /**
     * 获取统计信息
     */
    getStats(): Promise<{
        currentSession: string | null;
        memory: any;
        cache: any;
        storage: any;
    }>;
    /**
     * 构建包含上下文的消息列表
     */
    buildMessagesWithContext(userMessage: string, systemPrompt?: string, filterOptions?: ContextFilter): Promise<ContextMessage[]>;
    /**
     * 检查上下文组件是否已准备就绪
     */
    isContextReady(): boolean;
    /**
     * 获取上下文管理器实例（用于高级操作）
     */
    getContextManager(): ContextManager | undefined;
    /**
     * 确保组件已准备就绪
     */
    private ensureReady;
    /**
     * 记录日志
     */
    private log;
}

/**
 * 阿里云百练配置接口
 */
interface QwenConfig {
    apiKey: string;
    baseURL?: string;
}
/**
 * 阿里云百练 Qwen LLM 实现
 * 基于 OpenAI 兼容的 API 接口
 */
declare class QwenLLM extends BaseLLM {
    private client;
    private config;
    constructor(config: QwenConfig, defaultModel?: string);
    /**
     * 初始化组件
     */
    init(): Promise<void>;
    /**
     * 判断是否为 Qwen3 模型
     * 根据官方文档，现在大部分模型都基于 Qwen3
     */
    private isQwen3Model;
    /**
     * 获取 Qwen3 模型的 enable_thinking 默认值
     * 根据千问官方文档：
     * - Qwen3 商业版模型默认值为 False
     * - Qwen3 开源版模型默认值为 True
     * - 但某些场景下需要显式设置为 false
     */
    private getEnableThinkingValue;
    /**
     * 发送请求到阿里云百练
     */
    protected sendRequest(request: LLMRequest): Promise<LLMResponse>;
    /**
     * 测试 API 连接
     */
    private testConnection;
    /**
     * 流式聊天（阿里云百练支持）
     */
    streamChat(request: LLMRequest, onChunk: (chunk: string) => void): Promise<LLMResponse>;
    /**
     * 获取可用模型列表
     */
    getModels(): Promise<string[]>;
    /**
     * 设置系统提示词
     */
    chatWithSystem(systemPrompt: string, userMessage: string, options?: Partial<LLMRequest>): Promise<string>;
    /**
     * 函数调用（Qwen 支持函数调用）
     */
    functionCall(messages: any[], functions: any[], options?: Partial<LLMRequest>): Promise<any>;
    /**
     * 现代 Tools 格式的函数调用（推荐使用）
     * 支持 Qwen 最新的 tools 接口
     */
    toolsCall(messages: any[], tools: any[], options?: Partial<LLMRequest>): Promise<any>;
    /**
     * 自动选择最佳的函数调用方式
     * 优先使用 tools 格式，如果不支持则回退到 functions 格式
     */
    smartFunctionCall(messages: any[], toolsOrFunctions: any[], options?: Partial<LLMRequest>): Promise<any>;
    /**
     * 将工具定义转换为 OpenAI Tools 格式
     */
    private convertToToolsFormat;
    /**
     * 将工具定义转换为旧的 Functions 格式（向后兼容）
     */
    private convertToFunctionsFormat;
    /**
     * 解析 function call 或 tool call 的结果
     */
    parseToolCallResult(completion: any): {
        hasToolCalls: boolean;
        toolCalls: Array<{
            id?: string;
            type?: string;
            function: {
                name: string;
                arguments: string;
            };
        }>;
        content?: string;
    };
    /**
     * 执行完整的工具调用流程
     * 包括调用 LLM、解析工具调用、执行工具、返回结果
     */
    executeToolWorkflow(messages: any[], availableTools: any[], toolExecutor: (toolName: string, args: any) => Promise<any>, options?: Partial<LLMRequest>): Promise<{
        finalResponse: string;
        toolExecutions: Array<{
            toolName: string;
            arguments: any;
            result: any;
            success: boolean;
            error?: string;
        }>;
    }>;
    /**
     * 带 thinking 模式控制的聊天（仅适用于 Qwen3 模型）
     */
    chatWithThinking(request: LLMRequest, enableThinking?: boolean): Promise<LLMResponse>;
}

/**
 * 火山方舟配置接口
 */
interface VolcEngineConfig {
    apiKey: string;
    baseURL?: string;
    endpointId?: string;
}
/**
 * 火山方舟 LLM 实现
 * 基于 OpenAI 兼容的 API 接口
 */
declare class VolcEngineLLM extends BaseLLM {
    private client;
    private config;
    constructor(config: VolcEngineConfig, defaultModel?: string);
    /**
     * 初始化组件
     */
    init(): Promise<void>;
    /**
     * 发送请求到火山方舟
     */
    protected sendRequest(request: LLMRequest): Promise<LLMResponse>;
    /**
     * 测试 API 连接
     */
    private testConnection;
    /**
     * 流式聊天（火山方舟支持）
     */
    streamChat(request: LLMRequest, onChunk: (chunk: string) => void): Promise<LLMResponse>;
    /**
     * 获取可用模型列表
     */
    getModels(): Promise<string[]>;
}

/**
 * LLM 配置接口
 */
interface LLMConfig {
    provider: 'qwen' | 'volcengine';
    apiKey?: string;
    model?: string;
    baseURL?: string;
}
/**
 * LLM 管理器
 * 负责 LLM 实例的创建、初始化和管理
 */
declare class LLMManager {
    private llm?;
    private config?;
    private isInitialized;
    private debug;
    constructor(debug?: boolean);
    /**
     * 配置 LLM
     */
    configure(config: LLMConfig): void;
    /**
     * 初始化 LLM
     */
    init(): Promise<void>;
    /**
     * 销毁 LLM
     */
    destroy(): Promise<void>;
    /**
     * 检查 LLM 是否可用
     */
    isAvailable(): boolean;
    /**
     * 获取 LLM 提供商名称
     */
    getProvider(): string | null;
    /**
     * 获取 LLM 实例
     */
    getInstance(): QwenLLM | VolcEngineLLM | undefined;
    /**
     * 基础聊天
     */
    chat(message: string): Promise<string>;
    /**
     * 多轮对话
     */
    conversation(messages: LLMMessage[]): Promise<string>;
    /**
     * 流式聊天
     */
    streamChat(messages: LLMMessage[], onChunk: (chunk: string) => void): Promise<string>;
    /**
     * 系统提示词聊天
     */
    chatWithSystem(systemPrompt: string, userMessage: string): Promise<string>;
    /**
     * 代码生成
     */
    generateCode(description: string, language?: string): Promise<string>;
    /**
     * 文本摘要
     */
    summarize(text: string): Promise<string>;
    /**
     * 代码审查
     */
    reviewCode(code: string, language: string): Promise<string>;
    /**
     * 情绪分析
     */
    analyzeSentiment(text: string): Promise<string>;
    /**
     * 智能问答
     */
    ask(question: string): Promise<string>;
    /**
     * 使用 Qwen 的 Function Call 功能
     */
    functionCall(messages: any[], toolsOrFunctions: any[], options?: any): Promise<any>;
    /**
     * 解析工具调用结果
     */
    parseToolCallResult(completion: any): any;
    /**
     * 执行完整的工具调用工作流
     */
    executeToolWorkflow(messages: any[], availableTools: any[], toolExecutor: (toolName: string, args: any) => Promise<any>, options?: any): Promise<any>;
    /**
     * 获取状态信息
     */
    getStatus(): {
        isInitialized: boolean;
        isAvailable: boolean;
        provider: string | null;
        hasInstance: boolean;
    };
    /**
     * 确保 LLM 可用
     */
    private ensureLLMAvailable;
    /**
     * 日志记录
     */
    private log;
}

/**
 * MCP (Model Context Protocol) 类型定义
 */
interface MCPMessage {
    jsonrpc: '2.0';
    id?: string | number;
    method?: string;
    params?: Record<string, any>;
    result?: any;
    error?: MCPError;
}
interface MCPError {
    code: number;
    message: string;
    data?: any;
}
interface MCPResource {
    uri: string;
    name: string;
    description?: string;
    mimeType?: string;
}
interface MCPResourceContent {
    uri: string;
    mimeType: string;
    text?: string;
    blob?: string;
}
interface MCPTool {
    name: string;
    description: string;
    inputSchema: {
        type: 'object';
        properties: Record<string, any>;
        required?: string[];
    };
}
interface MCPToolCall {
    name: string;
    arguments: Record<string, any>;
}
interface MCPToolResult {
    content: Array<{
        type: 'text' | 'image' | 'resource';
        text?: string;
        data?: string;
        mimeType?: string;
    }>;
    isError?: boolean;
}
interface MCPPrompt {
    name: string;
    description: string;
    arguments?: Array<{
        name: string;
        description: string;
        required?: boolean;
    }>;
}
interface MCPPromptMessage {
    role: 'user' | 'assistant';
    content: {
        type: 'text' | 'image' | 'resource';
        text?: string;
        data?: string;
        mimeType?: string;
    };
}
interface MCPServerCapabilities {
    experimental?: Record<string, any>;
    logging?: {};
    prompts?: {
        listChanged?: boolean;
    };
    resources?: {
        subscribe?: boolean;
        listChanged?: boolean;
    };
    tools?: {
        listChanged?: boolean;
    };
}
interface MCPClientCapabilities {
    experimental?: Record<string, any>;
    sampling?: {};
}
interface MCPServerInfo {
    name: string;
    version: string;
    capabilities: MCPServerCapabilities;
}
interface MCPClientInfo {
    name: string;
    version: string;
    capabilities: MCPClientCapabilities;
}
interface MCPConnectionConfig {
    name: string;
    transport: 'stdio' | 'ws' | 'sse';
    endpoint?: string;
    command?: string;
    args?: string[];
    env?: Record<string, string>;
    timeout?: number;
    auth?: {
        type: 'bearer' | 'basic' | 'api-key';
        token?: string;
        username?: string;
        password?: string;
        apiKey?: string;
    };
}
interface MCPSession {
    id: string;
    config: MCPConnectionConfig;
    connected: boolean;
    serverInfo?: MCPServerInfo;
    lastActivity: Date;
}

/**
 * MCP 客户端实现
 */
declare class MCPClient extends EventEmitter {
    private sessions;
    private connections;
    private messageId;
    private readonly clientInfo;
    constructor();
    /**
     * 连接到 MCP 服务器
     */
    connect(config: MCPConnectionConfig): Promise<MCPSession>;
    /**
     * 断开连接
     */
    disconnect(sessionId: string): Promise<void>;
    /**
     * 获取所有会话
     */
    getSessions(): MCPSession[];
    /**
     * 获取指定会话
     */
    getSession(sessionId: string): MCPSession | undefined;
    /**
     * 列出资源
     */
    listResources(sessionId: string): Promise<MCPResource[]>;
    /**
     * 读取资源内容
     */
    readResource(sessionId: string, uri: string): Promise<MCPResourceContent>;
    /**
     * 列出工具
     */
    listTools(sessionId: string): Promise<MCPTool[]>;
    /**
     * 调用工具
     */
    callTool(sessionId: string, toolCall: MCPToolCall): Promise<MCPToolResult>;
    /**
     * 发送请求到 MCP 服务器
     */
    private sendRequest;
    /**
     * WebSocket 连接
     */
    private connectWebSocket;
    /**
     * Stdio 连接
     */
    private connectStdio;
    /**
     * 处理消息
     */
    private handleMessage;
    /**
     * 执行握手
     */
    private performHandshake;
}

/**
 * MCP 服务器配置
 */
interface MCPServerConfig {
    port?: number;
    host?: string;
    transport: 'ws' | 'stdio';
    auth?: {
        enabled: boolean;
        tokens?: string[];
    };
}
/**
 * MCP 服务器实现
 */
declare class MCPServer extends EventEmitter {
    private config;
    private server?;
    private wsServer?;
    private clients;
    private toolManager;
    private messageId;
    private readonly serverInfo;
    constructor(config: MCPServerConfig, toolManager?: ToolManager);
    /**
     * 启动服务器
     */
    start(): Promise<void>;
    /**
     * 停止服务器
     */
    stop(): Promise<void>;
    /**
     * 处理 WebSocket 连接
     */
    private handleConnection;
    /**
     * 处理 Stdio 连接
     */
    private handleStdioConnection;
    /**
     * 处理消息
     */
    private handleMessage;
    /**
     * 处理初始化请求
     */
    private handleInitialize;
    /**
     * 处理列出资源
     */
    private handleListResources;
    /**
     * 处理读取资源
     */
    private handleReadResource;
    /**
     * 处理列出工具
     */
    private handleListTools;
    /**
     * 处理工具调用
     */
    private handleCallTool;
    /**
     * 处理列出提示
     */
    private handleListPrompts;
    /**
     * 处理获取提示
     */
    private handleGetPrompt;
    /**
     * 发送响应
     */
    private sendResponse;
    /**
     * 发送错误
     */
    private sendError;
    /**
     * 发送错误到 Stdio
     */
    private sendErrorToStdio;
}

/**
 * MCP 配置管理
 */
declare class MCPConfig {
    private configPath;
    private config;
    constructor(configPath?: string);
    /**
     * 加载配置
     */
    private loadConfig;
    /**
     * 保存配置
     */
    private saveConfig;
    /**
     * 获取默认配置
     */
    private getDefaultConfig;
    /**
     * 添加服务器配置
     */
    addServer(name: string, config: MCPConnectionConfig): void;
    /**
     * 移除服务器配置
     */
    removeServer(name: string): void;
    /**
     * 获取服务器配置
     */
    getServer(name: string): MCPConnectionConfig | undefined;
    /**
     * 获取所有服务器配置
     */
    getServers(): Record<string, MCPConnectionConfig>;
    /**
     * 更新客户端配置
     */
    updateClientConfig(config: Partial<MCPClientConfig>): void;
    /**
     * 获取客户端配置
     */
    getClientConfig(): MCPClientConfig;
    /**
     * 更新服务器配置
     */
    updateServerConfig(config: Partial<MCPServerConfigFile>): void;
    /**
     * 获取服务器配置
     */
    getServerConfig(): MCPServerConfigFile;
    /**
     * 验证服务器配置
     */
    validateServerConfig(config: MCPConnectionConfig): string[];
    /**
     * 导出配置
     */
    exportConfig(): MCPConfigFile;
    /**
     * 导入配置
     */
    importConfig(config: MCPConfigFile): void;
    /**
     * 重置为默认配置
     */
    reset(): void;
}
/**
 * MCP 配置文件结构
 */
interface MCPConfigFile {
    servers: Record<string, MCPConnectionConfig>;
    client: MCPClientConfig;
    server: MCPServerConfigFile;
}
/**
 * MCP 客户端配置
 */
interface MCPClientConfig {
    timeout: number;
    retryAttempts: number;
    retryDelay: number;
}
/**
 * MCP 服务器配置文件
 */
interface MCPServerConfigFile {
    port: number;
    host: string;
    transport: 'ws' | 'stdio';
    auth: {
        enabled: boolean;
        tokens?: string[];
    };
}
declare const mcpConfig: MCPConfig;

/**
 * MCP 组件配置
 */
interface MCPComponentConfig {
    enabled?: boolean;
    servers?: string[];
    autoConnect?: boolean;
    debug?: boolean;
}
/**
 * MCP 资源信息
 */
interface MCPResourceInfo extends MCPResource {
    serverId: string;
    serverName: string;
}
/**
 * MCP 工具信息
 */
interface MCPToolInfo extends MCPTool {
    serverId: string;
    serverName: string;
}
/**
 * MCP 组件 - 管理 MCP 连接和资源
 */
declare class MCPComponent extends BaseComponent {
    private client?;
    private sessions;
    private resources;
    private tools;
    private config;
    private eventEmitter;
    constructor(id: string, config?: MCPComponentConfig);
    /**
     * 添加事件监听器
     */
    on(event: string, listener: (...args: any[]) => void): this;
    /**
     * 移除事件监听器
     */
    off(event: string, listener: (...args: any[]) => void): this;
    /**
     * 发射事件
     */
    private emit;
    /**
     * 初始化 MCP 组件
     */
    init(): Promise<void>;
    /**
     * 销毁 MCP 组件
     */
    destroy(): Promise<void>;
    /**
     * 连接到多个服务器
     */
    connectToServers(serverNames: string[]): Promise<void>;
    /**
     * 连接到单个服务器
     */
    connectToServer(config: MCPConnectionConfig): Promise<MCPSession>;
    /**
     * 断开服务器连接
     */
    disconnectFromServer(serverName: string): Promise<void>;
    /**
     * 加载服务器资源
     */
    loadServerResources(sessionId: string): Promise<void>;
    /**
     * 加载服务器工具
     */
    loadServerTools(sessionId: string): Promise<void>;
    /**
     * 获取所有可用资源
     */
    getAllResources(): MCPResourceInfo[];
    /**
     * 获取所有可用工具
     */
    getAllTools(): MCPToolInfo[];
    /**
     * 读取资源内容
     */
    readResource(uri: string): Promise<string | null>;
    /**
     * 调用 MCP 工具
     */
    callTool(toolName: string, args: Record<string, any>): Promise<any>;
    /**
     * 搜索资源
     */
    searchResources(query: string): MCPResourceInfo[];
    /**
     * 搜索工具
     */
    searchTools(query: string): MCPToolInfo[];
    /**
     * 获取连接状态
     */
    getConnectionStatus(): Array<{
        serverName: string;
        connected: boolean;
        resourceCount: number;
        toolCount: number;
    }>;
    /**
     * 根据 ID 获取会话
     */
    private getSessionById;
    /**
     * 日志记录
     */
    private log;
}

/**
 * 工具组件配置
 */
interface ToolComponentConfig extends ToolManagerConfig {
    /** 是否包含内置工具 */
    includeBuiltinTools?: boolean;
    /** 要排除的工具名称 */
    excludeTools?: string[];
    /** 要包含的工具分类 */
    includeCategories?: string[];
}
/**
 * 工具组件 - 为 Agent 提供工具管理和调用能力
 */
declare class ToolComponent extends BaseComponent {
    private toolManager?;
    private config;
    private eventEmitter;
    private isInitialized;
    constructor(id?: string, config?: ToolComponentConfig);
    init(): Promise<void>;
    destroy(): Promise<void>;
    /**
     * 获取工具管理器
     */
    getToolManager(): ToolManager;
    /**
     * 注册工具
     */
    registerTool(tool: ToolDefinition): Promise<void>;
    /**
     * 调用工具
     */
    callTool(request: ToolCallRequest): Promise<ToolCallResponse>;
    /**
     * 获取所有工具
     */
    getTools(): ToolDefinition[];
    /**
     * 按分类获取工具
     */
    getToolsByCategory(): Record<string, ToolDefinition[]>;
    /**
     * 搜索工具
     */
    searchTools(query: string): ToolDefinition[];
    /**
     * 获取工具信息
     */
    getToolInfo(toolName: string): ToolDefinition | undefined;
    /**
     * 启用/禁用工具
     */
    setToolEnabled(toolName: string, enabled: boolean): void;
    /**
     * 获取工具统计信息
     */
    getStats(): Record<string, any>;
    /**
     * 获取执行历史
     */
    getExecutionHistory(limit?: number): ToolExecutionHistory[];
    /**
     * 清空执行历史
     */
    clearHistory(): void;
    /**
     * 添加事件监听器
     */
    on(event: string, listener: (...args: any[]) => void): void;
    /**
     * 移除事件监听器
     */
    off(event: string, listener: (...args: any[]) => void): void;
    /**
     * 发送事件
     */
    emit(event: string, ...args: any[]): boolean;
    /**
     * 应用过滤器
     */
    private applyFilters;
    /**
     * 设置事件监听
     */
    private setupEventListeners;
    /**
     * 生成工具文档
     */
    generateToolDocs(): string;
    /**
     * 记录日志
     */
    private log;
    /**
     * 记录错误
     */
    private error;
}

/**
 * Agent 配置接口
 */
interface AgentConfig {
    debug?: boolean;
    llm?: LLMConfig;
    tools?: {
        enabled?: boolean;
        includeBuiltinTools?: boolean;
        excludeTools?: string[];
        includeCategories?: string[];
    };
    context?: ContextComponentConfig;
    mcp?: MCPComponentConfig;
    components?: ComponentManagerConfig;
}
/**
 * 工具调用结果
 */
interface ToolCallResult {
    toolName: string;
    success: boolean;
    result: any;
    error?: string;
    duration?: number;
}
/**
 * Agent 聊天响应
 */
interface AgentResponse {
    content: string;
    toolCalls?: ToolCallResult[];
    reasoning?: string;
}
/**
 * Agent 主类 - 智能代理的核心协调器
 * 专注于代理协调逻辑，LLM 和组件管理由专门的管理器负责
 */
declare class Agent extends EventEmitter {
    private config;
    private llmManager;
    private componentManager;
    private isInitialized;
    private isDestroyed;
    constructor(config?: AgentConfig);
    /**
     * 初始化 Agent 和所有管理器
     */
    init(): Promise<void>;
    /**
     * 销毁 Agent 和所有管理器
     */
    destroy(): Promise<void>;
    /**
     * 获取 LLM 管理器
     */
    getLLMManager(): LLMManager;
    /**
     * 获取组件管理器
     */
    getComponentManager(): ComponentManager;
    /**
     * 检查 LLM 是否可用
     */
    hasLLM(): boolean;
    /**
     * 获取 LLM 提供商名称
     */
    getLLMProvider(): string | null;
    /**
     * 基础聊天
     */
    chat(message: string): Promise<string>;
    /**
     * 多轮对话
     */
    conversation(messages: LLMMessage[]): Promise<string>;
    /**
     * 流式聊天
     */
    streamChat(messages: LLMMessage[], onChunk: (chunk: string) => void): Promise<string>;
    /**
     * 系统提示词聊天
     */
    chatWithSystem(systemPrompt: string, userMessage: string): Promise<string>;
    /**
     * 代码生成
     */
    generateCode(description: string, language?: string): Promise<string>;
    /**
     * 文本摘要
     */
    summarize(text: string): Promise<string>;
    /**
     * 代码审查
     */
    reviewCode(code: string, language: string): Promise<string>;
    /**
     * 情绪分析
     */
    analyzeSentiment(text: string): Promise<string>;
    /**
     * 智能问答
     */
    ask(question: string): Promise<string>;
    /**
     * 注册组件
     */
    registerComponent(component: BaseComponent): Promise<void>;
    /**
     * 获取组件
     */
    getComponent<T extends BaseComponent>(id: string): T | undefined;
    /**
     * 移除组件
     */
    removeComponent(id: string): Promise<boolean>;
    /**
     * 获取所有组件ID
     */
    getComponentIds(): string[];
    /**
     * 智能聊天 - 支持工具调用的完整流程
     * 这是 Agent 的核心协调逻辑
     */
    smartChat(message: string): Promise<AgentResponse>;
    /**
     * 分析用户消息是否需要工具调用
     */
    private analyzeToolNeed;
    /**
     * 智能调用工具
     */
    private callToolSmart;
    /**
     * 基于工具结果生成最终回答
     */
    private generateAnswerWithToolResults;
    /**
     * 获取工具组件
     */
    getToolComponent(): ToolComponent | undefined;
    /**
     * 获取上下文组件
     */
    getContextComponent(): ContextComponent | undefined;
    /**
     * 获取 MCP 组件
     */
    getMCPComponent(): MCPComponent | undefined;
    /**
     * 创建新的上下文会话
     */
    createContextSession(userId?: string, preferences?: Record<string, any>, configuration?: Record<string, any>, customSessionId?: string): Promise<string>;
    /**
     * 加载现有的上下文会话
     */
    loadContextSession(sessionId: string): Promise<boolean>;
    /**
     * 获取当前上下文会话ID
     */
    getCurrentSessionId(): string | undefined;
    /**
     * 搜索历史会话
     */
    searchContextSessions(query: string, limit?: number): Promise<Array<{
        sessionId: string;
        summary: string;
        lastActivity: number;
        relevanceScore: number;
    }>>;
    /**
     * 带上下文的智能聊天
     */
    chatWithContext(message: string, systemPrompt?: string, options?: ContextFilter): Promise<string>;
    /**
     * 带上下文的智能工具调用聊天
     */
    smartChatWithContext(message: string): Promise<AgentResponse>;
    /**
     * 获取上下文统计信息
     */
    getContextStats(): Promise<{
        currentSession: string | null;
        memory: any;
        cache: any;
        storage: any;
    } | null>;
    /**
     * 手动调用工具
     */
    callTool(toolName: string, parameters: Record<string, any>): Promise<ToolCallResult>;
    /**
     * 获取可用工具列表
     */
    getAvailableTools(): ToolDefinition[];
    /**
     * 搜索工具
     */
    searchTools(query: string): ToolDefinition[];
    /**
     * 获取 Agent 状态
     */
    getStatus(): {
        initialized: boolean;
        destroyed: boolean;
        llm: {
            isInitialized: boolean;
            isAvailable: boolean;
            provider: string | null;
            hasInstance: boolean;
        };
        components: {
            isInitialized: boolean;
            isDestroyed: boolean;
            componentCount: number;
            componentIds: string[];
            config: ComponentManagerConfig;
        };
        hasLLM: boolean;
        llmProvider: string | null;
    };
    /**
     * 获取健康状态
     */
    getHealthStatus(): Promise<{
        healthy: boolean;
        agent: {
            initialized: boolean;
            destroyed: boolean;
        };
        llm: {
            isInitialized: boolean;
            isAvailable: boolean;
            provider: string | null;
            hasInstance: boolean;
        };
        components: {
            healthy: boolean;
            components: {
                [id: string]: {
                    healthy: boolean;
                    error?: string;
                };
            };
        };
    }>;
    /**
     * 自动注册默认组件
     */
    private autoRegisterComponents;
    /**
     * 设置管理器事件转发
     */
    private setupManagerEventForwarding;
    /**
     * 内部日志记录
     */
    private log;
}

/**
 * 日志组件
 * 示例组件，用于处理和记录系统日志
 */
declare class LoggerComponent extends BaseComponent {
    private enabled;
    private logLevel;
    constructor(idOrLogLevel?: string | 'debug' | 'info' | 'warn' | 'error');
    /**
     * 设置日志级别
     */
    setLogLevel(level: 'debug' | 'info' | 'warn' | 'error'): void;
    /**
     * 初始化日志组件
     */
    init(): Promise<void>;
    /**
     * 销毁日志组件
     */
    destroy(): Promise<void>;
    /**
     * 记录调试信息
     */
    debug(message: string): void;
    /**
     * 记录一般信息
     */
    info(message: string): void;
    /**
     * 记录警告信息
     */
    warn(message: string): void;
    /**
     * 记录错误信息
     */
    error(message: string, error?: Error): void;
    /**
     * 检查是否应该记录给定级别的日志
     */
    private shouldLog;
    /**
     * 记录日志的内部方法
     */
    private log;
}

/**
 * 默认配置模块
 * 管理 LLM 的默认配置参数
 */
interface LLMProviderConfig {
    apiKey: string;
    defaultModel: string;
    baseURL?: string;
    supportedModels: string[];
    modelDescriptions?: Record<string, string>;
}
interface DefaultConfig {
    llm: {
        qwen: LLMProviderConfig;
        volcengine: LLMProviderConfig;
    };
}
/**
 * 默认配置
 * 注意：API密钥必须通过环境变量或--api-key参数提供
 */
declare const DEFAULT_CONFIG: DefaultConfig;
/**
 * 获取指定提供商的配置
 */
declare function getProviderConfig(provider: 'qwen' | 'volcengine'): LLMProviderConfig;
/**
 * 获取所有支持的提供商列表
 */
declare function getSupportedProviders(): string[];
/**
 * 检查提供商是否受支持
 */
declare function isProviderSupported(provider: string): provider is 'qwen' | 'volcengine';
/**
 * 从环境变量加载配置
 */
declare function loadConfigFromEnv(): Partial<DefaultConfig>;

export { Agent, type AgentConfig, type AgentResponse, BaseComponent, BaseLLM, DEFAULT_CONFIG, type DefaultConfig, type LLMMessage, type LLMProviderConfig, type LLMRequest, type LLMResponse, LoggerComponent, MCPClient, type MCPClientCapabilities, type MCPClientConfig, type MCPClientInfo, MCPConfig, type MCPConfigFile, type MCPConnectionConfig, type MCPError, type MCPMessage, type MCPPrompt, type MCPPromptMessage, type MCPResource, type MCPResourceContent, MCPServer, type MCPServerCapabilities, type MCPServerConfig, type MCPServerConfigFile, type MCPServerInfo, type MCPSession, type MCPTool, type MCPToolCall, type MCPToolResult, QwenLLM, type ToolCallRequest, type ToolCallResponse, type ToolCallResult, ToolComponent, type ToolComponentConfig, type ToolDefinition, type ToolExecutionContext, ToolExecutionError, type ToolExecutionHistory, type ToolExecutionResult, ToolManager, type ToolManagerConfig, type ToolParameterSchema, ToolRegistrationError, type ToolRegistrationOptions, ToolValidationError, ToolValidator, VolcEngineLLM, createToolManager, fileSystemTools, getAllBuiltinTools, getBuiltinToolsByCategory, getProviderConfig, getSupportedProviders, gitTools, isProviderSupported, loadConfigFromEnv, mcpConfig, networkTools, smartTools, textProcessingTools, utilityTools };