import type { AgentEngine, LLMProvider, Middleware, RegisteredTool, ToolRegistry, SkillManager, Skill, ContextManager, ContentPart, Message, ProxySettings, AgentEventPreset, A2AClient, ObservabilityConfig, ObservabilityManager, ResponseFormat } from '@cicctencent/agent-core';
import type { ObservabilityStoreProvider } from './spi/observability-store.js';
export interface ThreadEntity {
    id: number;
    workspaceId?: number;
    title: string;
    summary?: string;
    status: 'active' | 'archived' | 'deleted';
    messageCount: number;
    agentProfileId?: number;
    source?: 'local' | 'a2a';
    automationRunId?: number;
    createdAt: string;
    updatedAt: string;
}
export interface MessageEntity {
    id: number;
    threadId: number;
    type: 'text' | 'code' | 'tool_call' | 'reasoning' | 'image';
    role: 'user' | 'assistant' | 'system';
    content: string;
    meta?: Record<string, any>;
    createdAt: string;
    updatedAt?: string;
}
export interface WorkspaceEntity {
    id: number;
    name: string;
    description?: string;
    color?: string;
    icon?: string;
    status: 'active' | 'archived';
    threadCount: number;
    automationCount: number;
    createdAt: string;
    updatedAt: string;
}
export interface ModelProviderConfig {
    id: string;
    name: string;
    provider: string;
    model: string;
    apiKey?: string;
    baseUrl?: string;
    timeout?: number;
    maxTokens?: number;
    temperature?: number;
    enabled?: boolean;
}
export interface SettingsEntity {
    theme: 'dark' | 'light' | 'system';
    language: string;
    apiKeys: {
        provider?: string;
        openai?: string;
        anthropic?: string;
        customEndpoint?: string;
        customModel?: string;
    };
    notifications: {
        taskComplete: boolean;
    };
    agentConfig?: {
        basePrompt?: string;
        maxIterations?: number;
        maxMessages?: number;
        toolTimeout?: number;
        defaultTools?: string[];
        contextBudget?: {
            maxToolOutput?: number;
            compactThreshold?: number;
            maxContextTokens?: number;
        };
        deniedTools?: string[];
        toolDiscovery?: 'full' | 'summary' | 'summary-all';
        toolSummaryMaxDesc?: number;
        /** summary-all 模式下保持全量 schema 的核心工具名列表 */
        coreToolNames?: string[];
        retryPolicy?: {
            maxRetries?: number;
            initialDelay?: number;
            maxDelay?: number;
            backoffFactor?: number;
        };
        fallbackProvider?: string;
        modelTierStrategy?: 'uniform' | 'role_based';
        modelTiers?: Record<string, string>;
    };
    modelProviders?: ModelProviderConfig[];
    defaultModelId?: string;
    proxySettings?: ProxySettings;
}
export type MCPTransportType = 'stdio' | 'http' | 'sse' | 'streamableHttp' | 'api-bridge' | 'code';
export type MCPServerStatusType = 'disconnected' | 'connected' | 'error';
export interface MCPToolDefinition {
    name: string;
    description: string;
    parameters?: {
        type: 'object';
        properties: Record<string, {
            type: string;
            description: string;
            enum?: string[];
        }>;
        required?: string[];
    };
    executorType?: string;
    executorMeta?: Record<string, unknown>;
}
export interface MCPServerEntity {
    id: number | string;
    name: string;
    description?: string;
    transport: MCPTransportType;
    command?: string;
    args?: string[];
    env?: Record<string, string>;
    endpoint?: string;
    headers?: Record<string, string>;
    enabled: boolean;
    status: MCPServerStatusType;
    toolCount: number;
    lastError?: string;
    toolDefinitions?: MCPToolDefinition[];
    connectorId?: string;
    requestBuilderId?: string;
    urlTemplate?: string;
    apiRoot?: string;
    apiMapping?: Record<string, Record<string, unknown>>;
    relay?: {
        url: string;
        headers?: Record<string, string>;
    };
    auth?: {
        type: 'bearer' | 'basic' | 'apiKey' | 'custom';
        value: string;
        name?: string;
    };
    response?: {
        extract?: string;
        errorField?: string;
        errorMessage?: string;
        map?: {
            template: string;
        };
        join?: string;
        template?: string;
    };
    dataSourceType?: string;
    dataSourceConfig?: Record<string, unknown>;
    /** code transport: 用户编写的 MCP Server 代码 */
    code?: string;
    /** code transport: 代码运行时类型 (nodejs | python) */
    codeRuntime?: 'nodejs' | 'python';
    createdAt: string;
}
export type ConnectorStatusType = 'draft' | 'installed' | 'error';
export interface ConnectorEntity {
    id: string;
    name: string;
    description?: string;
    icon?: string;
    color?: string;
    category?: string;
    version?: string;
    author?: string;
    mcpServerIds: (number | string)[];
    skillIds: string[];
    enabled: boolean;
    status: ConnectorStatusType;
    dataSourceType?: string;
    dataSourceConfig?: Record<string, unknown>;
    createdAt: string;
    updatedAt: string;
}
export interface AgentProfileEntity {
    id: number;
    name: string;
    description?: string;
    icon?: string;
    color?: string;
    basePrompt: string;
    model?: string;
    modelConfigId?: string;
    maxIterations?: number;
    maxMessages?: number;
    toolTimeout?: number;
    /** 迭代守卫配置（如 iterationGuardThreshold；空时回落引擎默认 0.35） */
    guardConfig?: Record<string, any>;
    /** 数据获取类工具集合（守卫触发时将被禁用的工具名；空时回落引擎默认集合） */
    dataFetchTools?: string[];
    /** 脚本执行超时硬上限（毫秒），不设置时由引擎回退默认 1800000(30分钟) */
    maxScriptTimeoutMs?: number;
    /** LLM 单次请求超时（毫秒），不设置时回退默认 180000 */
    llmTimeout?: number;
    /** 该 Agent 作为子 Agent 被委派时的超时（毫秒）；不设置时回退到全局默认 */
    delegateTimeoutMs?: number;
    disabledTools?: string[];
    /** 工具白名单：非空时仅这些工具（+ builtin 类工具）可用，与 disabledTools 互补 */
    selectedTools?: string[];
    mcpServers?: (number | string)[];
    selectedSkills?: string[];
    alwaysInjectSkills?: string[];
    connectorIds?: string[];
    isDefault?: boolean;
    agentType?: 'default' | 'specialist' | 'remote';
    remoteUrl?: string;
    remoteCard?: {
        url?: string;
        name?: string;
        description?: string;
        [key: string]: unknown;
    };
    remoteAuth?: {
        type: 'bearer' | 'basic' | 'apiKey' | 'custom';
        value: string;
        name?: string;
        extraHeaders?: {
            name: string;
            value: string;
        }[];
    };
    a2aProtocol?: 'jsonrpc' | 'rest';
    /** 远程 Agent 输出模式: merge(合并到主正文) | panel(保留子面板) */
    a2aOutputMode?: 'merge' | 'panel';
    /** 远程 Agent 自身的 A2A 超时（毫秒）；作为委派超时的次级兜底（低于 delegateTimeoutMs） */
    a2aTimeout?: number;
    /** 远程 Agent A2A SSE 连接超时（毫秒），0/未设置使用默认 30000 */
    a2aConnectTimeout?: number;
    /** 远程 Agent A2A SSE 逐 chunk 读取超时（毫秒），0/未设置使用默认 60000 */
    a2aChunkTimeout?: number;
    restA2AConfig?: {
        capabilityId: string;
        staticFields?: Record<string, string>;
        taskField?: string;
        /** 流式失败时是否自动回退到同步模式，默认 true */
        fallbackToSync?: boolean;
        /** 允许 LLM 动态填写的字段名列表 */
        dynamicFields?: string[];
        /** 流式调用的 action 后缀（默认 'stream'），如 URL 含 :stream 则自动提取 */
        streamAction?: string;
        /** 同步调用的 action 后缀（默认 'invoke'），如对方使用 :run 则填 'run' */
        invokeAction?: string;
    };
    domain?: string;
    /** 优先级（数值越高越优先，默认为 0） */
    priority?: number;
    /** 适用范围/领域标签 */
    scope?: string[];
    /** 触发关键词 */
    keywords?: string[];
    /** 排他性范围：当用户意图落在此范围内时，此 Agent 可独立完成任务 */
    exclusiveScope?: string[];
    /**
     * 是否可用于对话（工作台直接对话、可被委派）。
     * true(默认): 出现在对话选择与委派列表；
     * false: 仅可通过接口/自动化等外部方式调用执行，不出现在对话选择与委派列表。
     */
    chatEnabled?: boolean;
    /**
     * 是否支持委派子 Agent（即是否可调用 delegate_task 把子任务分发给 Specialist/Remote）。
     * true(默认): 可在工具配置中启用「委派子任务」并可委派；
     * false: 不可委派，delegate_task 不会被注册，也无法在工具配置中勾选。
     */
    canDelegate?: boolean;
    /**
     * 是否支持被其它 Agent 委派为子 Agent（即作为 delegate_task 的候选 Specialist）。
     * true(默认): 可被其它 Agent 当作子 Agent 委派；
     * false: 不可被委派，不会出现在其它 Agent 的 delegate_task 候选列表中。
     * 与 canDelegate（主动委派）正交：一个 Agent 可主动委派别人但不愿被别人委派。
     */
    canBeDelegated?: boolean;
    /** Agent 开关配置 JSON（统一存储所有布尔开关，如 chatEnabled/canDelegate/allowInteraction） */
    agentOptions?: Record<string, any> | null;
    /** 是否允许 Agent 中断并向用户提问(ask_user)，API 层已归一化为 boolean */
    allowInteraction?: boolean;
    /** 结构化输出约束（Profile 级默认；请求级可用 RunOptions.responseFormat 覆盖） */
    responseFormat?: ResponseFormat;
    /** 模型降级策略（可选）：fallbackModelConfigId 等为模型路由降级链提供备选模型配置 */
    modelPolicy?: {
        /** 主模型失败时降级到的模型配置 ID */
        fallbackModelConfigId?: string;
    };
    createdAt: string;
    updatedAt: string;
}
export interface SkillData {
    id: string;
    name: string;
    description: string;
    tags: string[];
    category: string;
    content: string;
    source: 'system';
    version?: string;
    author?: string;
    filePath?: string;
    isActive: boolean;
    connectorId?: string;
    requires?: string[];
}
export type DataSourceType = 'database' | 'filesystem' | 'message-queue' | 'http-api' | 'mcp' | 'email' | 'calendar' | 'finance';
/** 数据源连接配置（所有数据源类型的并集） */
export interface DataSourceConfig {
    /** 数据源名称 */
    name: string;
    /** 数据源类型 */
    type: DataSourceType;
    /** 是否启用 */
    enabled?: boolean;
    description?: string;
    /** 数据库类型: mysql / postgres / mongodb / clickhouse */
    dbType?: 'mysql' | 'postgres' | 'mongodb' | 'clickhouse';
    /** 数据库主机 */
    host?: string;
    /** 数据库端口 */
    port?: number;
    /** 数据库名 */
    database?: string;
    /** 数据库用户名 */
    username?: string;
    /** 数据库密码 */
    password?: string;
    /** 额外连接参数 (SSL 等) */
    extraOptions?: Record<string, any>;
    /** 根目录路径 */
    rootPath?: string;
    /** 允许的扩展名 */
    allowedExtensions?: string[];
    /** 是否只读 */
    readOnly?: boolean;
    /** HTTP API 模式: manual / openapi */
    apiMode?: 'manual' | 'openapi';
    /** OpenAPI spec URL 或内联 JSON */
    openapiSpec?: string;
    /** 服务配置列表（多服务实例） */
    services?: ServiceConfig[];
    /** 全局请求头 */
    globalHeaders?: Record<string, string>;
    /** 全局认证 token */
    authToken?: string;
    /** 认证类型: bearer / basic / apikey / none */
    authType?: 'bearer' | 'basic' | 'apikey' | 'none';
    /** MCP 传输方式: stdio / sse / streamable-http */
    mcpTransport?: 'stdio' | 'sse' | 'streamable-http';
    /** MCP 命令（stdio 模式） */
    command?: string;
    /** MCP 参数 */
    args?: string[];
    /** MCP 环境变量 */
    env?: Record<string, string>;
    /** MCP URL（sse / streamable-http 模式） */
    url?: string;
    /** IMAP 主机 */
    imapHost?: string;
    /** IMAP 端口 */
    imapPort?: number;
    /** SMTP 主机 */
    smtpHost?: string;
    /** SMTP 端口 */
    smtpPort?: number;
    /** 是否使用 TLS */
    useTLS?: boolean;
    /** 邮箱地址 */
    emailAddress?: string;
    /** 日历类型: local / caldav */
    calendarType?: 'local' | 'caldav';
    /** CalDAV 服务器 URL */
    caldavUrl?: string;
    /** 日历名称 */
    calendarName?: string;
    /** MQ 类型: rabbitmq / kafka */
    mqType?: 'rabbitmq' | 'kafka';
    /** MQ topic / queue 列表 */
    topics?: string[];
    /** 消费组 ID（Kafka） */
    groupId?: string;
    /** @deprecated 使用 dbType */
    dbDriver?: 'mysql' | 'postgres' | 'mongodb' | 'clickhouse';
    /** @deprecated 使用 host */
    dbHost?: string;
    /** @deprecated 使用 port */
    dbPort?: number;
    /** @deprecated 使用 username */
    dbUser?: string;
    /** @deprecated 使用 password */
    dbPassword?: string;
    /** @deprecated 使用 database */
    dbName?: string;
    /** @deprecated 使用 extraOptions */
    dbOptions?: Record<string, any>;
    /** @deprecated 使用 rootPath */
    fsRootPath?: string;
    /** @deprecated 使用 allowedExtensions */
    fsAllowedExtensions?: string[];
    /** @deprecated 使用 readOnly（语义相反） */
    fsWritable?: boolean;
    /** @deprecated 使用 mqType */
    mqDriver?: 'rabbitmq' | 'kafka';
    /** @deprecated 使用 host + port（amqp://host:port 或 host:port） */
    mqUrl?: string;
    /** @deprecated 使用 topics */
    mqTopics?: string[];
    /** @deprecated 使用 groupId */
    mqGroupId?: string;
    /** @deprecated 使用（语义相反，只读模式由运行时控制） */
    mqWritable?: boolean;
    /** @deprecated 邮箱协议：imap / gmail-api / outlook-api / exchange / exchange-ews */
    emailProtocol?: 'imap' | 'gmail-api' | 'outlook-api' | 'exchange' | 'exchange-ews';
    smtpSecure?: boolean;
    smtpUser?: string;
    smtpPass?: string;
    smtpFrom?: string;
    imapSecure?: boolean;
    imapUser?: string;
    imapPass?: string;
    exchangeTenantId?: string;
    exchangeClientId?: string;
    exchangeClientSecret?: string;
    exchangeFromEmail?: string;
    exchangeFromName?: string;
    ewsUrl?: string;
    ewsUsername?: string;
    ewsPassword?: string;
    ewsFromEmail?: string;
    /** @deprecated 使用 calendarType */
    calendarBackend?: 'local' | 'caldav' | 'google-api';
    caldavUser?: string;
    caldavPass?: string;
    [key: string]: unknown;
}
/** HTTP API / MCP 多服务配置（多服务实例）
 *
 *  支持两套字段形态（规范 + 兼容别名）：
 *  - 规范（work-space）: baseUrl + endpoints[{ path, bodySchema, querySchema }] + authToken + authType
 *  - 兼容（work-client）: apiRoot + httpMode + openapiUrl + endpoints[{ entry, parameters }] + auth{ type, value }
 *  适配器读取时优先用规范键，缺失时回退到兼容键。
 */
export interface ServiceConfig {
    name: string;
    /** 规范：API 根地址 */
    baseUrl?: string;
    /** 兼容：API 根地址 */
    apiRoot?: string;
    /** 兼容：manual / openapi */
    httpMode?: 'manual' | 'openapi';
    /** 兼容：OpenAPI 文档地址 */
    openapiUrl?: string;
    /** 规范：全局认证 token */
    authToken?: string;
    /** 规范：认证类型 */
    authType?: 'bearer' | 'basic' | 'apikey' | 'none';
    /** 兼容：认证配置 */
    auth?: {
        type: 'bearer' | 'basic' | 'apiKey' | 'custom';
        value: string;
        name?: string;
    };
    headers?: Record<string, string>;
    endpoints?: EndpointConfig[];
    /** MCP 传输方式 */
    mcpTransport?: 'stdio' | 'sse' | 'http' | 'streamableHttp';
    /** MCP 命令（stdio） */
    mcpCommand?: string;
    /** MCP 参数 */
    mcpArgs?: string[];
    /** MCP 端点 URL（sse / http） */
    mcpEndpoint?: string;
    /** MCP 自定义请求头 */
    mcpHeaders?: Record<string, string>;
    /** MCP 环境变量 */
    mcpEnv?: Record<string, string>;
}
/** HTTP API 端点定义（规范 + 兼容别名） */
export interface EndpointConfig {
    name: string;
    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
    /** 规范：路径模板 */
    path?: string;
    /** 兼容：路径模板（支持 ${param}） */
    entry?: string;
    description?: string;
    headers?: Record<string, string>;
    bodySchema?: Record<string, any>;
    querySchema?: Record<string, any>;
    /** 兼容：参数定义 */
    parameters?: Record<string, {
        type: string;
        description: string;
        required?: boolean;
        enum?: string[];
    }>;
}
/** 工具发现结果 */
export interface DiscoveredTool {
    name: string;
    description: string;
    /** 参数 JSON Schema */
    inputSchema: Record<string, any>;
    /** 输出 JSON Schema（可选） */
    outputSchema?: Record<string, any>;
    executorType?: string;
    executorMeta?: Record<string, unknown>;
}
/** 连接测试结果 */
export interface ConnectionTestResult {
    success: boolean;
    /** 消息 */
    message: string;
    /** 发现的资源（表、文件、端点等） */
    resources?: string[];
    /** 错误详情 */
    error?: string;
    /** 连接测试耗时（毫秒），由适配器在 testConnection 中测量 */
    latency?: number;
    /** 额外信息（如数据库版本、表数量、可达服务数等） */
    info?: Record<string, unknown>;
}
/** MCP 服务器配置（适配器生成的） */
export interface MCPServerConfig {
    name: string;
    transport: 'stdio' | 'sse' | 'streamable-http' | 'api-bridge';
    command?: string;
    args?: string[];
    env?: Record<string, string>;
    url?: string;
    /** api-bridge 传输：API 根地址 */
    apiRoot?: string;
    /** api-bridge 传输：URL 模板，默认 '{apiRoot}/{entry}' */
    urlTemplate?: string;
    /** api-bridge 传输：工具名 → 端点映射 */
    apiMapping?: Record<string, Record<string, unknown>>;
    /** 认证配置 */
    auth?: {
        type: 'bearer' | 'basic' | 'apiKey' | 'custom';
        value: string;
        name?: string;
    };
    /** 请求构建器 ID（api-bridge） */
    requestBuilderId?: string;
    headers?: Record<string, string>;
    relay?: {
        url: string;
        headers?: Record<string, string>;
    };
    response?: {
        extract?: string;
        errorField?: string;
        errorMessage?: string;
        map?: {
            template: string;
        };
        join?: string;
        template?: string;
    };
    tools: DiscoveredTool[];
}
/** 数据源类型描述（供前端向导展示） */
export interface DataSourceTypeInfo {
    type: DataSourceType;
    label: string;
    description: string;
    icon: string;
    drivers?: {
        value: string;
        label: string;
        defaultPort: number;
    }[];
    /** 该类型需要的配置字段列表 */
    configFields: {
        key: string;
        label: string;
        type: 'text' | 'password' | 'number' | 'select' | 'path' | 'tags' | 'textarea' | 'json';
        placeholder?: string;
        required?: boolean;
        options?: {
            value: string;
            label: string;
        }[];
    }[];
}
/** 数据源适配器接口 */
export interface DataSourceAdapter {
    readonly type: DataSourceType;
    /** 适配器显示名（用于向导展示） */
    readonly label?: string;
    /** 适配器支持的驱动列表（用于向导展示） */
    readonly drivers?: string[];
    testConnection(config: DataSourceConfig): Promise<ConnectionTestResult>;
    discoverTools(config: DataSourceConfig): Promise<DiscoveredTool[]>;
    /**
     * 生成连接器 manifest.json 内容（仅元信息 + dataSourceConfig，不含 MCP 服务器配置）。
     * @param config 数据源配置
     * @param tools 发现的工具列表（来自 discoverTools，可被用户筛选后的子集）
     */
    generateManifest(config: DataSourceConfig, tools?: DiscoveredTool[]): Record<string, unknown>;
    /**
     * 生成 MCP 服务器配置（用于写入连接器包的 mcp-servers/ 目录）。
     * @returns 每个 MCP 服务器一项；tools 为完整工具定义（含 executorType / executorMeta）。
     */
    generateMCPServerConfigs(config: DataSourceConfig, tools?: DiscoveredTool[]): MCPServerConfig[];
}
/** 设置存储提供者 */
export interface SettingsProvider {
    getSettings(tenant?: TenantContext): SettingsEntity;
    updateSettings(updates: Partial<SettingsEntity>, tenant?: TenantContext): SettingsEntity;
    resetSettings?(tenant?: TenantContext): SettingsEntity;
}
/** 对话存储提供者 */
export interface ChatStoreProvider {
    getThreads(workspaceId?: number, tenant?: TenantContext): ThreadEntity[] | Promise<ThreadEntity[]>;
    getThread(id: number, tenant?: TenantContext): ThreadEntity | undefined | Promise<ThreadEntity | undefined>;
    createThread(data: {
        title?: string;
        workspaceId?: number;
        source?: 'local' | 'a2a';
    }, tenant?: TenantContext): ThreadEntity | Promise<ThreadEntity>;
    updateThread(id: number, data: Partial<ThreadEntity>, tenant?: TenantContext): ThreadEntity | undefined | Promise<ThreadEntity | undefined>;
    deleteThread(id: number, tenant?: TenantContext): boolean | Promise<boolean>;
    getMessages(threadId: number, options?: {
        limit?: number;
        offset?: number;
    }, tenant?: TenantContext): {
        items: MessageEntity[];
        total: number;
        hasMore: boolean;
    } | Promise<{
        items: MessageEntity[];
        total: number;
        hasMore: boolean;
    }>;
    addMessage(data: {
        threadId: number;
        role: string;
        content: string;
        type?: string;
        meta?: any;
    }, tenant?: TenantContext): MessageEntity | Promise<MessageEntity>;
    updateMessage(threadId: number, id: number, data: {
        content?: string;
        meta?: any;
    }, tenant?: TenantContext): MessageEntity | undefined | Promise<MessageEntity | undefined>;
    deleteMessage(threadId: number, id: number, tenant?: TenantContext): boolean | Promise<boolean>;
    clearThreadMessages(threadId: number, tenant?: TenantContext): void | Promise<void>;
    buildThreadHistory(threadId: number, limit?: number, tenant?: TenantContext): Message[] | Promise<Message[]>;
}
/** Prompt 构建者 */
export interface PromptBuilderProvider {
    buildDefaultPrompt(profile: AgentProfileEntity, tools: ToolRegistry, memory?: string, specialists?: AgentProfileEntity[], specialistResourceMap?: Record<string, {
        connectorNames: string[];
        mcpServerNames: string[];
    }>, skills?: SkillManager): string;
    buildSpecialistPrompt(profile: AgentProfileEntity, tools: ToolRegistry, skills: SkillManager, memory?: string): string;
    resolveToolDisplayName(toolName: string, registry: ToolRegistry): string;
}
/** 模型配置解析者 */
export interface ModelConfigResolver {
    resolve(modelConfigId?: string): ModelProviderConfig;
    createProvider(modelConfigId?: string, modelOverride?: string): LLMProvider;
    /** 创建降级 Provider（主模型失败时使用）；实现类可选支持 */
    createFallbackProvider?(modelConfigId?: string): LLMProvider;
    /** 按场景解析模型配置（如 subagent）；实现类可选支持 */
    resolveForScene?(scene: string): LLMProvider | undefined;
}
/** MCP 服务提供者 */
export interface MCPServiceProvider {
    listServers(): MCPServerEntity[];
    getServer(id: number | string): MCPServerEntity | undefined;
    addServer(data: Partial<MCPServerEntity> & {
        name: string;
        transport: MCPTransportType;
    }): MCPServerEntity;
    updateServer(id: number | string, data: Partial<MCPServerEntity>): MCPServerEntity | undefined;
    removeServer(id: number | string): boolean;
    toggleServer(id: number | string, enabled: boolean): MCPServerEntity | undefined;
    testConnection(id: number | string): Promise<{
        success: boolean;
        toolCount: number;
        error?: string;
    }>;
    getServerTools(id: number | string): MCPToolDefinition[];
    syncToolsToRegistry(registry: ToolRegistry): Promise<{
        connected: number;
        tools: number;
        errors: string[];
    }>;
    disconnectAll(): void;
    removeServersByConnector(connectorId: string): number;
    clearConnectorCache(connectorId: string): void;
}
/** Skill 服务提供者 */
export interface SkillServiceProvider {
    listSkills(): SkillData[];
    getSkill(id: string): SkillData | null;
    searchSkills(options?: {
        query?: string;
        limit?: number;
        includeInactive?: boolean;
        includeConnector?: boolean;
        category?: string;
        tags?: string[];
    }): Array<SkillData & {
        score: number;
        matchedFields: string[];
    }>;
    toggleSkill(id: string, active: boolean): SkillData | null;
    deleteSkill(id: string): boolean;
    reloadSkills(): {
        count: number;
    };
}
/** 连接器服务提供者 */
export interface ConnectorServiceProvider {
    listConnectors(): ConnectorEntity[];
    getConnector(id: string): ConnectorEntity | undefined;
    toggleConnector(id: string, enabled: boolean): ConnectorEntity | undefined;
    deleteConnector(id: string): {
        success: boolean;
        error?: string;
    };
    autoDiscoverConnectors(): Promise<void>;
    reloadConnectors(): Promise<{
        connectors: number;
        synced: string[];
    }>;
    isConnectorSkillEnabled(connectorId: string, skillId: string): boolean;
    setConnectorSkillEnabled(connectorId: string, skillId: string, enabled: boolean): void;
}
/** Agent Profile 服务提供者 */
export interface AgentProfileProvider {
    listProfiles(tenant?: TenantContext): AgentProfileEntity[] | Promise<AgentProfileEntity[]>;
    getProfile(id: number, tenant?: TenantContext): AgentProfileEntity | undefined | Promise<AgentProfileEntity | undefined>;
    getDefaultProfile(tenant?: TenantContext): AgentProfileEntity | undefined | Promise<AgentProfileEntity | undefined>;
    createProfile(data: Partial<AgentProfileEntity>, tenant?: TenantContext): AgentProfileEntity | Promise<AgentProfileEntity>;
    updateProfile(id: number, data: Partial<AgentProfileEntity>, tenant?: TenantContext): AgentProfileEntity | undefined | Promise<AgentProfileEntity | undefined>;
    deleteProfile(id: number, tenant?: TenantContext): boolean | Promise<boolean>;
}
/** 自动化任务服务提供者 */
export interface AutomationProvider {
    /** 刷新调度器（CRUD 后调用） */
    refreshScheduler(): void;
    /** 手动触发任务 */
    triggerAutomation?(id: number): Promise<string>;
    /** 停止正在运行的自动化任务（中止当前执行 + 禁用后续调度） */
    stopAutomation?(id: number): Promise<{
        stopped: boolean;
        message: string;
    }>;
    /** 获取活跃任务数 */
    getActiveJobCount?(): number;
}
/** 邮件服务提供者 */
export interface EmailProvider {
    /** 发送邮件 */
    send(message: import('@cicctencent/agent-core').EmailMessage): Promise<void>;
}
/** 日历服务提供者 */
export interface CalendarProvider {
    /** 创建事件 */
    create(event: Omit<CalendarEvent, 'id'>): Promise<CalendarEvent>;
    /** 更新事件 */
    update?(id: string, updates: Partial<CalendarEvent>): Promise<CalendarEvent | null>;
    /** 删除事件 */
    delete?(id: string): Promise<boolean>;
    /** 查询事件列表 */
    list(startTime?: string, endTime?: string): Promise<CalendarEvent[]>;
    /** 获取单个事件 */
    get?(id: string): Promise<CalendarEvent | null>;
    /** 生成 iCal 格式 */
    generateICal?(events: CalendarEvent[]): Promise<string>;
}
/** 日历事件实体 */
export interface CalendarEvent {
    id: string;
    title: string;
    description?: string;
    start: string;
    end?: string;
    allDay?: boolean;
    location?: string;
    attendees?: string[];
    organizer?: string;
    reminderMinutes?: number;
}
/**
 * 缓存配置。
 *
 * agent-server 在多进程部署时，对 Settings / Profile / Engine 做本地 TTL 缓存。
 * - TTL 到期自动过期，下次请求重新从 Provider（DB）加载
 * - 主动失效通过 `AgentServer.invalidateProfileCache()` / `invalidateSettingsCache()` 触发
 * - 跨进程失效通过 `CacheInvalidationNotifier` 实现（如 Redis pub/sub）
 */
export interface CacheConfig {
    /** Engine 缓存 TTL（ms），默认 5 分钟。设为 0 禁用缓存 */
    engineTTL?: number;
    /** Engine 缓存最大数量，默认 10 */
    engineMaxSize?: number;
    /** Profile 缓存 TTL（ms），默认 60 秒。设为 0 禁用缓存（每次直接查 Provider） */
    profileTTL?: number;
    /** Settings 缓存 TTL（ms），默认 60 秒。设为 0 禁用缓存 */
    settingsTTL?: number;
}
/** 缓存失效范围 */
export type CacheInvalidationScope = 'profile' | 'settings' | 'all';
/**
 * 跨进程缓存失效通知者。
 *
 * 多进程/多实例部署时，一个进程更新了配置后，需通知其他进程清除本地缓存。
 * 上层应用可用 Redis pub/sub、MQ 等实现 `notifyInvalidate` + `onInvalidate`。
 *
 * agent-server 会在本地缓存失效后自动调用 `notifyInvalidate` 广播通知；
 * 收到 `onInvalidate` 回调后会清除本地对应缓存。
 */
export interface CacheInvalidationNotifier {
    /** 广播缓存失效通知给其他进程 */
    notifyInvalidate(scope: CacheInvalidationScope, key?: number | string): void;
    /** 订阅缓存失效通知（agent-server 注册回调，收到通知后清除本地缓存） */
    onInvalidate(handler: (scope: CacheInvalidationScope, key?: number | string) => void): () => void;
}
export interface AgentServerOptions {
    /** LLM Provider（必选） */
    llmProvider: LLMProvider;
    /** 降级 LLM Provider */
    fallbackProvider?: LLMProvider;
    settingsProvider?: SettingsProvider;
    chatStoreProvider?: ChatStoreProvider;
    promptBuilder?: PromptBuilderProvider;
    modelConfigResolver?: ModelConfigResolver;
    mcpServiceProvider?: MCPServiceProvider;
    skillServiceProvider?: SkillServiceProvider;
    connectorServiceProvider?: ConnectorServiceProvider;
    agentProfileProvider?: AgentProfileProvider;
    automationProvider?: AutomationProvider;
    emailProvider?: EmailProvider;
    calendarProvider?: CalendarProvider;
    /** 自定义工具集（完全替换内置工具，默认加载全部内置工具） */
    tools?: RegisteredTool[];
    /** 在内置工具基础上追加自定义工具 */
    extraTools?: RegisteredTool[];
    /** 自定义数据源适配器 */
    connectors?: DataSourceAdapter[];
    middleware?: Middleware[];
    /** 可观测性存储 SPI（未提供时使用 InMemoryObservabilityStore） */
    observabilityProvider?: ObservabilityStoreProvider;
    /** 可观测性配置（采样率、输入/输出捕获开关等） */
    observabilityConfig?: ObservabilityConfig;
    dataDir?: string;
    skillsDir?: string;
    connectorsDir?: string;
    /**
     * 直接注入的 Skill 列表（DB 源）。
     * 提供后，baseSkillManager 由这些 Skills 构建（以 name 为唯一标识），
     * 不再从 skillsDir 读取投影文件。未提供时回退到 loadFromDir(skillsDir)。
     */
    skills?: Skill[];
    maxIterations?: number;
    maxMessages?: number;
    toolTimeout?: number;
    /** 脚本执行超时硬上限（毫秒），默认 1800000(30分钟) */
    maxScriptTimeoutMs?: number;
    /** LLM 单次请求超时（毫秒），默认 180000 */
    llmTimeout?: number;
    basePrompt?: string;
    /** SSE 事件映射预设，默认 'sse'。BI 项目使用 'bi' 输出前端兼容格式 */
    sseEventPreset?: AgentEventPreset;
    /**
     * 缓存配置。
     *
     * 上层 Web 项目通常多进程部署，agent-server 需对 Settings / Profile 等配置做 TTL 缓存以减少 DB 压力，
     * 同时支持主动失效。EnginePool 的 TTL 也通过此配置调整。
     */
    cache?: CacheConfig;
    /**
     * 跨进程缓存失效通知者。
     *
     * 多进程部署时，一个进程更新了 Profile / Settings 后，需通过此接口通知其他进程清除本地缓存。
     * 上层可用 Redis pub/sub、MQ 等实现。未提供时仅当前进程生效。
     */
    cacheInvalidationNotifier?: CacheInvalidationNotifier;
    onInit?: (server: AgentServer) => void;
    /** 是否在创建后自动预热引擎（默认 false）。应用层通常自行管理预热时机 */
    prewarm?: boolean;
    /** 应用层覆盖默认设置值（如 theme、language 等） */
    defaultSettings?: Partial<SettingsEntity>;
    /** 应用层覆盖默认 Agent Profile 的显示配置（名称、图标、颜色等） */
    defaultProfileConfig?: {
        name?: string;
        description?: string;
        icon?: string;
        color?: string;
        basePrompt?: string;
    };
    /**
     * 自定义 Memory 存储实现。
     *
     * 提供后替代默认的 MemoryService（JSON 文件存储），
     * 上层应用可注入 DB 实现（如 work-space 的 MemoryDBStore）。
     */
    memoryStore?: {
        save(entry: {
            userId: string;
            threadId: string | number;
            content: string;
            category: string;
            relevance?: number;
            expiresAt?: number;
            meta?: any;
        }): Promise<any>;
        getByThread(threadId: string | number, limit?: number): Promise<any[]>;
        getByUser(userId: string, category?: string, limit?: number): Promise<any[]>;
        search(userId: string, query: string, topK?: number): Promise<any[]>;
        delete(id: string | number): Promise<boolean>;
        clearThread(threadId: string | number): Promise<void>;
        load(userId: string, options?: {
            threadId?: number | string;
            category?: string;
            limit?: number;
        }): Promise<any[]>;
        clear(userId: string): Promise<void>;
    };
    /**
     * A2A 客户端实例，用于创建远程 Agent 的 SubAgentRunner。
     *
     * 提供后，getEngineForProfile() 会自动为 agentType='remote' 的 Profile
     * 创建 createA2ARemoteRunner，并注册 delegate_task 工具。
     * 未提供时，远程 Agent 会被跳过（不影响本地 specialist）。
     */
    a2aClient?: A2AClient;
    /**
     * 判断当前 Profile 是否允许委派子任务（加载 specialist/remote 并注册 delegate_task）。
     *
     * 默认规则：`profile.isDefault === true || profile.agentType === 'default'`
     * 上层可覆盖，例如 BI 项目可传入 `(p) => p.agentType !== 'remote'`。
     *
     * 返回 false 的 Agent 不会注册 delegate_task，无法委派子任务。
     */
    canDelegate?: boolean | ((profile: AgentProfileEntity, context: {
        /** 是否作为子 Agent 运行（入口 Agent 为 false，被 delegate_task 创建的子 Agent 为 true） */
        isSubAgent: boolean;
        /** 父 Agent 的 profileId（子 Agent 场景有值） */
        parentProfileId?: number;
        /** 当前会话 ID（入口 Agent 场景从 RunAgentParams.threadId 透传，子 Agent 场景为 undefined） */
        sessionId?: string;
    }) => boolean);
    /**
     * delegate_task 单次委派超时时间（毫秒）。
     *
     * 超时后返回错误信息，避免子 Agent 长时间阻塞。
     * 默认不限制（由 tool-executor 的全局超时控制）。
     */
    delegateTimeoutMs?: number;
    /**
     * 默认租户上下文。
     *
     * 如果 `RunAgentParams.tenant` 未传，则使用此默认值。
     * 适用于单租户场景（所有请求共享同一租户上下文）。
     */
    defaultTenant?: TenantContext;
}
/**
 * SSE 流式响应的最小接口。
 *
 * 兼容 Express Response、Fastify Reply、原生 http.ServerResponse 等。
 * 上层应用只需将框架的响应对象适配为此接口即可。
 *
 * 此接口与 SPI 的 `SSEResponseAdapter` 结构一致，统一使用本类型。
 */
export interface SSEResponse {
    /** 写入字符串数据到响应流 */
    write(data: string): void;
    /** 结束响应 */
    end(): void;
    /** 响应是否已结束写入 */
    readonly writableEnded: boolean;
    /** 设置响应头 */
    setHeader(name: string, value: string | number): void;
    /** flush 响应头 */
    flushHeaders?(): void;
    /** 设置 HTTP 状态码（错误响应时使用） */
    status?(code: number): void;
    /** 返回 JSON 响应（错误响应时使用） */
    json?(data: any): void;
}
export interface AgentServer {
    /** Agent 系统实例 */
    agentSystem: AgentSystem;
    /** 动态注册/注销工具 */
    registerTool(tool: RegisteredTool): void;
    unregisterTool(name: string): void;
    /** 动态注册/注销中间件 */
    registerMiddleware(mw: Middleware): void;
    unregisterMiddleware(name: string): void;
    /** 运行 Agent SSE 流 */
    runAgentStream(res: SSEResponse, params: RunAgentParams, signal?: AbortSignal): Promise<void>;
    /** 重连 Agent SSE 流 */
    reconnectAgentStream(res: SSEResponse, threadId: number): Promise<void>;
    /** 获取引擎 */
    getEngineForProfile(profileId?: number, profileOverride?: AgentProfileEntity, skipCache?: boolean, tenant?: TenantContext, isSubAgent?: boolean, allowedSpecialistIds?: number[], sessionId?: string): AgentEngine | Promise<AgentEngine>;
    /** 获取主引擎 */
    getEngine(): AgentEngine | null;
    /** 中止指定会话的 Agent 执行 */
    abortAgent(threadId: number | string): boolean;
    /** 暂停指定会话的 Agent 执行（当前工具/LLM 调用完成后在 turn 边界挂起）。若无运行则返回 false。 */
    pauseAgent(threadId: number | string): boolean;
    /** 恢复暂停的会话执行。若会话无运行记录则返回 false。 */
    resumeAgent(threadId: number | string): boolean;
    /** 查询会话是否处于暂停状态 */
    isPaused(threadId: number | string): boolean;
    /** 向运行中的 Agent 发送 steering 消息 */
    steerAgent(sessionId: string, message: string): boolean;
    /** 清空引擎缓存池 */
    clearEnginePool(): void;
    /** 刷新 LLM 配置 */
    refreshLLMConfig(): void;
    /** 刷新 Agent 引擎配置 */
    refreshAgentConfig(): void;
    /** 清除 Profile 缓存。指定 profileId 时仅清除该 profile，不指定时清除全部。同时失效对应 Engine 缓存。 */
    invalidateProfileCache(profileId?: number): void;
    /** 清除 Settings 缓存 */
    invalidateSettingsCache(): void;
    /** 重新同步 MCP 工具 */
    refreshMCPTools(): Promise<{
        connected: number;
        tools: number;
        errors: string[];
    }>;
    /** 获取已注册的工具列表 */
    getRegisteredTools(): Array<{
        name: string;
        description: string;
        category: string;
    }>;
    /** 获取已加载的技能列表 */
    getLoadedSkills(): Array<{
        id: string;
        name: string;
        description: string;
        tags: string[];
        content: string;
    }>;
    /** 获取已注册的中间件列表 */
    getRegisteredMiddlewares(): ReadonlyArray<Middleware>;
    /** 诊断某个工具是否被禁用（profile 维度），用于排查工具不可用问题。
     *  注意：自修复后单 Agent 的 disabledTools 是唯一权威，全局 settings.deniedTools 不再覆盖单 Agent；
     *  settingsDeniedTools 仅作展示。系统级硬阻断见 security-policy.denyTools。 */
    diagnoseDeniedTools(opts: {
        profileId?: number | string;
        tool?: string;
        tenant?: TenantContext;
    }): Promise<{
        tool: string;
        toolRegistered: boolean;
        denied: boolean;
        deniedBy: Array<'profile'>;
        profileDisabledTools: string[];
        settingsDeniedTools: string[];
    }>;
    /** 获取用量统计 */
    getUsageStats(filter?: {
        startTime?: number;
        endTime?: number;
        agentProfileId?: string;
        provider?: string;
        model?: string;
    }): any;
    /** 获取用量原始记录 */
    getUsageRecords(filter?: {
        startTime?: number;
        endTime?: number;
        agentProfileId?: string;
        provider?: string;
        model?: string;
    }): any[];
    /** 检查 Agent 系统是否可用 */
    isAgentAvailable(): boolean;
    /** 获取 Agent 不可用的原因 */
    getAgentUnavailableReason(): string;
    /** 检查运行状态 */
    checkRunStatus(threadId: number): {
        hasActiveRun: boolean;
        status: string;
        messageId?: number;
        eventCount: number;
        checkpointCount: number;
    };
    /** 获取 SPI 提供者 */
    readonly providers: {
        settings?: SettingsProvider;
        chatStore?: ChatStoreProvider;
        promptBuilder?: PromptBuilderProvider;
        modelConfigResolver?: ModelConfigResolver;
        mcpService?: MCPServiceProvider;
        skillService?: SkillServiceProvider;
        connectorService?: ConnectorServiceProvider;
        agentProfile?: AgentProfileProvider;
        automation?: AutomationProvider;
        email?: EmailProvider;
        calendar?: CalendarProvider;
        observability?: ObservabilityStoreProvider;
        observabilityManager?: ObservabilityManager;
    };
}
export interface AgentSystem {
    engine: AgentEngine;
    toolRegistry: ToolRegistry;
    skillManager: SkillManager;
    contextManager: ContextManager;
    llmProvider: LLMProvider;
}
/**
 * 多租户上下文。
 *
 * 多租户 Web 项目中，不同租户/用户的 Agent 运行需要隔离：
 * - Engine 缓存按租户隔离（相同 profileId 在不同租户下不冲突）
 * - RunRegistry 按租户隔离（不同租户的运行状态不互窜）
 * - Memory 按租户隔离（不同租户的记忆不共享）
 * - SPI Provider 可根据租户上下文过滤数据（如只查当前用户的 Thread）
 *
 * 单租户场景可不传，行为与之前一致。
 */
export interface TenantContext {
    /** 租户 ID（多租户 SaaS 场景） */
    tenantId?: string;
    /** 用户 ID（单租户多用户场景） */
    userId?: string | number;
    /** 额外上下文（应用层自定义） */
    [key: string]: unknown;
}
/**
 * Run 完成后的上下文，传递给 onRunComplete 钩子。
 *
 * 上层应用可在此回调中执行记忆抽取、决策记忆落库、通知等副作用，
 * 无需在 runAgentStream 外部自行拼接运行结果。
 */
export interface RunCompleteContext {
    threadId: number;
    sessionId: string;
    agentProfileId?: number;
    /** 用户原始输入文本（从 content 中提取） */
    userMessage: string;
    /** 主运行收集到的完整输出文本 */
    finalText: string;
    /** 运行状态：done=正常完成, error=异常 */
    status: 'done' | 'error';
    /** 内核 RunRegistry 维护的 checkpoint 列表（仅 workflow 运行时非空） */
    checkpoints: import('@cicctencent/agent-core').WorkflowCheckpoint[];
    /** 总步数 */
    stepCount: number;
    /** 工具调用次数 */
    toolCallCount: number;
    /** 多租户上下文 */
    tenant?: TenantContext;
}
export interface RunAgentParams {
    content: string | ContentPart[];
    threadId?: string;
    agentProfileId?: number;
    traceId?: string;
    /** 多租户上下文（多租户/多用户场景必传） */
    tenant?: TenantContext;
    /**
     * 允许委派的 Specialist Agent Profile ID 列表。
     *
     * 由上层应用根据应用配置传入，用于过滤 delegate_task 可用的 specialist。
     * 未传时不过滤（向后兼容，加载所有 specialist）。
     */
    allowedSpecialistIds?: number[];
    /**
     * 自定义上下文，会合并到 engine 的 custom context 中。
     *
     * 用于上层应用注入 session 级别的沙箱执行器（shell/fs/sandbox），
     * 覆盖 agent-server 默认的全局 executor，实现文件隔离。
     *
     * 示例：
     *   params.customContext = { shell: sandboxShell, fs: sandboxFs, sandbox };
     */
    customContext?: Record<string, unknown>;
    /**
     * 测试模式：禁用委派（delegate_task），不持久化消息。
     * 用于 Agent 配置页面调试，确保仅测试当前 Agent 自身能力。
     */
    testMode?: boolean;
    /**
     * 暂停后恢复模式：content 允许为空，引擎以内部继续提示词驱动 LLM
     * 从持久化历史重建上下文继续执行（不追加额外 user 消息）。
     */
    resumeFromPause?: boolean;
    /**
     * 结构化输出约束（请求级覆盖，优先级高于 Profile 级默认）。
     * 经 agent-server 透传至内核 engine.run 的 RunOptions.responseFormat。
     */
    responseFormat?: ResponseFormat;
    /**
     * 调试模式：开启后 MCP / A2A（含委派远程 Agent）调用的网络诊断信息
     * 经 agent-debug SSE 事件推送到前端。与 testMode 解耦--正式对话（需委派）
     * 也可开启调试而不禁用 delegate_task。
     */
    debug?: boolean;
    /**
     * Run 完成后的回调（在 SSE 响应关闭前调用）。
     *
     * 用于上层应用执行 post-run 副作用：记忆抽取、决策记忆落库、通知等。
     * 回调中的异常被捕获并记录，不影响主流程。
     */
    onRunComplete?: (ctx: RunCompleteContext) => Promise<void> | void;
}
export interface SpecialistResourceContext {
    connectorNames: string[];
    mcpServerNames: string[];
}
//# sourceMappingURL=types.d.ts.map