@chatbi-v/core 2.1.9 → 3.0.0

package/dist/index.d.cts

@@ -1,7 +1,543 @@
-import React, { Component, ReactNode, ErrorInfo } from 'react';
-import * as react_jsx_runtime from 'react/jsx-runtime';
+import { z } from 'zod';
+import * as zustand from 'zustand';
+import * as zustand_middleware from 'zustand/middleware';
+export { AdapterFactory, AdapterRegistry, AdapterState, AdapterStatus, BaseAdapter, TransformOptions, UIAdapter, adapterRegistry } from './adapter/index.cjs';
 import dayjs from 'dayjs';
 
+/**
+ * @file branded.ts
+ * @description 品牌类型 (Branded Types) - 用于创建防错的标识符类型
+ */
+
+/**
+ * 创建品牌类型的工具类型
+ * @description 使用 string literal type 作为 Brand，实现编译时类型区分
+ */
+type brand<T, Brand extends string> = T & {
+    __brand: Brand;
+};
+/**
+ * PluginId 品牌类型
+ * @description 用于标识插件的唯一 ID，通过编译时类型防止字符串类型混淆
+ */
+type PluginId = brand<string, 'PluginId'>;
+/**
+ * SlotKey 品牌类型
+ * @description 用于标识插槽位置的唯一键，通过编译时类型防止字符串类型混淆
+ */
+type SlotKey = brand<string, 'SlotKey'>;
+/**
+ * PluginId 的 Zod 验证 Schema
+ */
+declare const PluginIdSchema: z.ZodString;
+/**
+ * SlotKey 的 Zod 验证 Schema
+ */
+declare const SlotKeySchema: z.ZodString;
+/**
+ * 创建类型安全的 PluginId
+ * @param id - 插件 ID 字符串
+ * @returns 带品牌标记的 PluginId 类型
+ */
+declare function createPluginId(id: string): PluginId;
+/**
+ * 创建类型安全的 SlotKey
+ * @param key - 插槽键字符串
+ * @returns 带品牌标记的 SlotKey 类型
+ */
+declare function createSlotKey(key: string): SlotKey;
+/**
+ * 类型守卫：检查是否为有效的 PluginId
+ * @param value - 要检查的值
+ * @returns 是否为 PluginId 类型
+ */
+declare function isPluginId(value: unknown): value is PluginId;
+/**
+ * 类型守卫：检查是否为有效的 SlotKey
+ * @param value - 要检查的值
+ * @returns 是否为 SlotKey 类型
+ */
+declare function isSlotKey(value: unknown): value is SlotKey;
+
+/**
+ * Plugin Manifest Schema 定义
+ * @description 使用 Zod 定义声明式插件元数据 Schema，支持扩展点声明
+ */
+
+/** 扩展点类型 */
+declare const EXTENSION_TYPES: readonly ["slot", "hook", "command", "service"];
+type ExtensionType = typeof EXTENSION_TYPES[number];
+/**
+ * 扩展点渲染模式
+ * @description 定义插槽内容的渲染方式
+ */
+declare const RENDER_MODES: readonly ["replace", "append", "prepend"];
+type RenderMode = typeof RENDER_MODES[number];
+/**
+ * 扩展点 Schema
+ * @description 定义插件提供的扩展能力
+ */
+declare const ExtensionSchema: z.ZodObject<{
+    /** 扩展点名称/标识符 */
+    name: z.ZodString;
+    /** 扩展点类型 */
+    type: z.ZodEnum<["slot", "hook", "command", "service"]>;
+    /** 扩展点描述 */
+    description: z.ZodOptional<z.ZodString>;
+    /** 对于 slot 类型，指定插槽位置 */
+    slot: z.ZodOptional<z.ZodString>;
+    /** 扩展点的配置选项 */
+    config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    /**
+     * 渲染模式
+     * @description 定义插槽内容的渲染方式：replace(替换)、append(追加)、prepend(前置)
+     */
+    renderMode: z.ZodOptional<z.ZodEnum<["replace", "append", "prepend"]>>;
+    /**
+     * 条件渲染配置
+     * @description 用于条件渲染，如 requiresAuth: true 表示需要认证
+     */
+    condition: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "slot" | "hook" | "command" | "service";
+    slot?: string | undefined;
+    description?: string | undefined;
+    config?: Record<string, any> | undefined;
+    renderMode?: "replace" | "append" | "prepend" | undefined;
+    condition?: Record<string, any> | undefined;
+}, {
+    name: string;
+    type: "slot" | "hook" | "command" | "service";
+    slot?: string | undefined;
+    description?: string | undefined;
+    config?: Record<string, any> | undefined;
+    renderMode?: "replace" | "append" | "prepend" | undefined;
+    condition?: Record<string, any> | undefined;
+}>;
+/**
+ * 依赖项 Schema
+ * @description 定义插件依赖的其他插件
+ */
+declare const DependencySchema: z.ZodObject<{
+    /** 依赖插件 ID */
+    id: z.ZodString;
+    /** 依赖版本范围 (SemVer) */
+    version: z.ZodString;
+    /** 是否为可选依赖 */
+    optional: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    version: string;
+    optional: boolean;
+}, {
+    id: string;
+    version: string;
+    optional?: boolean | undefined;
+}>;
+/** 插件类型 */
+declare const PLUGIN_TYPES: readonly ["business", "functional", "view", "theme", "renderer", "system"];
+type PluginType = typeof PLUGIN_TYPES[number];
+/**
+ * 入口点 Schema
+ * @description 定义插件入口文件位置
+ */
+declare const EntrySchema: z.ZodUnion<[z.ZodString, z.ZodObject<{
+    /** 入口文件 URL */
+    url: z.ZodString;
+    /** 共享作用域 (用于模块联邦) */
+    shareScope: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    shareScope?: string | undefined;
+}, {
+    url: string;
+    shareScope?: string | undefined;
+}>]>;
+/**
+ * 兼容性 Schema
+ * @description 定义插件兼容的宿主环境版本
+ */
+declare const CompatibilitySchema: z.ZodObject<{
+    /** 最低宿主版本 */
+    minVersion: z.ZodOptional<z.ZodString>;
+    /** 最高宿主版本 */
+    maxVersion: z.ZodOptional<z.ZodString>;
+    /** 兼容的宿主版本列表 */
+    supportedVersions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    minVersion?: string | undefined;
+    maxVersion?: string | undefined;
+    supportedVersions?: string[] | undefined;
+}, {
+    minVersion?: string | undefined;
+    maxVersion?: string | undefined;
+    supportedVersions?: string[] | undefined;
+}>;
+/** 权限动作类型 */
+declare const PERMISSION_ACTIONS: readonly ["read", "write", "execute", "admin"];
+type PermissionAction = typeof PERMISSION_ACTIONS[number];
+/** 权限作用域类型 */
+declare const PERMISSION_SCOPES: readonly ["plugin", "global", "user"];
+type PermissionScope = typeof PERMISSION_SCOPES[number];
+/**
+ * Plugin Manifest Schema - 声明式插件元数据
+ * @description 定义插件的静态属性，用于插件市场展示、权限校验和内核加载
+ */
+declare const PluginManifestSchema: z.ZodObject<{
+    /** 插件唯一 ID (推荐反向域名格式) */
+    id: z.ZodString;
+    /** 插件版本号 (SemVer) */
+    version: z.ZodEffects<z.ZodString, string, string>;
+    /** 插件显示名称 */
+    name: z.ZodString;
+    /** 插件入口 */
+    entry: z.ZodUnion<[z.ZodString, z.ZodObject<{
+        /** 入口文件 URL */
+        url: z.ZodString;
+        /** 共享作用域 (用于模块联邦) */
+        shareScope: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        shareScope?: string | undefined;
+    }, {
+        url: string;
+        shareScope?: string | undefined;
+    }>]>;
+    /** 插件类型 */
+    type: z.ZodDefault<z.ZodOptional<z.ZodEnum<["business", "functional", "view", "theme", "renderer", "system"]>>>;
+    /** 插件功能描述 */
+    description: z.ZodOptional<z.ZodString>;
+    /** 插件作者 */
+    author: z.ZodOptional<z.ZodString>;
+    /** 插件图标 */
+    icon: z.ZodOptional<z.ZodString>;
+    /** 兼容性要求 */
+    compatibility: z.ZodOptional<z.ZodObject<{
+        /** 最低宿主版本 */
+        minVersion: z.ZodOptional<z.ZodString>;
+        /** 最高宿主版本 */
+        maxVersion: z.ZodOptional<z.ZodString>;
+        /** 兼容的宿主版本列表 */
+        supportedVersions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        minVersion?: string | undefined;
+        maxVersion?: string | undefined;
+        supportedVersions?: string[] | undefined;
+    }, {
+        minVersion?: string | undefined;
+        maxVersion?: string | undefined;
+        supportedVersions?: string[] | undefined;
+    }>>;
+    /** 插件依赖 */
+    dependencies: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** 依赖插件 ID */
+        id: z.ZodString;
+        /** 依赖版本范围 (SemVer) */
+        version: z.ZodString;
+        /** 是否为可选依赖 */
+        optional: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        version: string;
+        optional: boolean;
+    }, {
+        id: string;
+        version: string;
+        optional?: boolean | undefined;
+    }>, "many">>>;
+    /** 扩展点声明 */
+    extensions: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        /** 扩展点名称/标识符 */
+        name: z.ZodString;
+        /** 扩展点类型 */
+        type: z.ZodEnum<["slot", "hook", "command", "service"]>;
+        /** 扩展点描述 */
+        description: z.ZodOptional<z.ZodString>;
+        /** 对于 slot 类型，指定插槽位置 */
+        slot: z.ZodOptional<z.ZodString>;
+        /** 扩展点的配置选项 */
+        config: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        /**
+         * 渲染模式
+         * @description 定义插槽内容的渲染方式：replace(替换)、append(追加)、prepend(前置)
+         */
+        renderMode: z.ZodOptional<z.ZodEnum<["replace", "append", "prepend"]>>;
+        /**
+         * 条件渲染配置
+         * @description 用于条件渲染，如 requiresAuth: true 表示需要认证
+         */
+        condition: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        type: "slot" | "hook" | "command" | "service";
+        slot?: string | undefined;
+        description?: string | undefined;
+        config?: Record<string, any> | undefined;
+        renderMode?: "replace" | "append" | "prepend" | undefined;
+        condition?: Record<string, any> | undefined;
+    }, {
+        name: string;
+        type: "slot" | "hook" | "command" | "service";
+        slot?: string | undefined;
+        description?: string | undefined;
+        config?: Record<string, any> | undefined;
+        renderMode?: "replace" | "append" | "prepend" | undefined;
+        condition?: Record<string, any> | undefined;
+    }>, "many">>>;
+    /** 能力声明 */
+    capabilities: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
+    /** 配置项定义 */
+    configuration: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        type: z.ZodEnum<["string", "number", "boolean", "select"]>;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        default: z.ZodOptional<z.ZodAny>;
+        options: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            label: z.ZodString;
+            value: z.ZodAny;
+        }, "strip", z.ZodTypeAny, {
+            label: string;
+            value?: any;
+        }, {
+            label: string;
+            value?: any;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        type: "string" | "number" | "boolean" | "select";
+        key: string;
+        label: string;
+        options?: {
+            label: string;
+            value?: any;
+        }[] | undefined;
+        description?: string | undefined;
+        default?: any;
+    }, {
+        type: "string" | "number" | "boolean" | "select";
+        key: string;
+        label: string;
+        options?: {
+            label: string;
+            value?: any;
+        }[] | undefined;
+        description?: string | undefined;
+        default?: any;
+    }>, "many">>;
+    /** 存储定义 */
+    storage: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    /** 路由定义 (仅供展示，实际路由在运行时注册) */
+    routes: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+    }, {
+        path: string;
+    }>, "many">>;
+    /** 权限声明 */
+    permissions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        action: z.ZodEnum<["read", "write", "execute", "admin"]>;
+        scope: z.ZodEnum<["plugin", "global", "user"]>;
+        resource: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        action: "read" | "write" | "execute" | "admin";
+        scope: "plugin" | "global" | "user";
+        resource: string;
+    }, {
+        action: "read" | "write" | "execute" | "admin";
+        scope: "plugin" | "global" | "user";
+        resource: string;
+    }>, "many">>;
+    /** 插件优先级 */
+    priority: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    type: "business" | "functional" | "view" | "theme" | "renderer" | "system";
+    id: string;
+    version: string;
+    entry: string | {
+        url: string;
+        shareScope?: string | undefined;
+    };
+    dependencies: {
+        id: string;
+        version: string;
+        optional: boolean;
+    }[];
+    extensions: {
+        name: string;
+        type: "slot" | "hook" | "command" | "service";
+        slot?: string | undefined;
+        description?: string | undefined;
+        config?: Record<string, any> | undefined;
+        renderMode?: "replace" | "append" | "prepend" | undefined;
+        condition?: Record<string, any> | undefined;
+    }[];
+    priority: number;
+    description?: string | undefined;
+    author?: string | undefined;
+    icon?: string | undefined;
+    compatibility?: {
+        minVersion?: string | undefined;
+        maxVersion?: string | undefined;
+        supportedVersions?: string[] | undefined;
+    } | undefined;
+    capabilities?: Record<string, boolean> | undefined;
+    configuration?: {
+        type: "string" | "number" | "boolean" | "select";
+        key: string;
+        label: string;
+        options?: {
+            label: string;
+            value?: any;
+        }[] | undefined;
+        description?: string | undefined;
+        default?: any;
+    }[] | undefined;
+    storage?: any[] | undefined;
+    routes?: {
+        path: string;
+    }[] | undefined;
+    permissions?: {
+        action: "read" | "write" | "execute" | "admin";
+        scope: "plugin" | "global" | "user";
+        resource: string;
+    }[] | undefined;
+}, {
+    name: string;
+    id: string;
+    version: string;
+    entry: string | {
+        url: string;
+        shareScope?: string | undefined;
+    };
+    type?: "business" | "functional" | "view" | "theme" | "renderer" | "system" | undefined;
+    description?: string | undefined;
+    author?: string | undefined;
+    icon?: string | undefined;
+    compatibility?: {
+        minVersion?: string | undefined;
+        maxVersion?: string | undefined;
+        supportedVersions?: string[] | undefined;
+    } | undefined;
+    dependencies?: {
+        id: string;
+        version: string;
+        optional?: boolean | undefined;
+    }[] | undefined;
+    extensions?: {
+        name: string;
+        type: "slot" | "hook" | "command" | "service";
+        slot?: string | undefined;
+        description?: string | undefined;
+        config?: Record<string, any> | undefined;
+        renderMode?: "replace" | "append" | "prepend" | undefined;
+        condition?: Record<string, any> | undefined;
+    }[] | undefined;
+    capabilities?: Record<string, boolean> | undefined;
+    configuration?: {
+        type: "string" | "number" | "boolean" | "select";
+        key: string;
+        label: string;
+        options?: {
+            label: string;
+            value?: any;
+        }[] | undefined;
+        description?: string | undefined;
+        default?: any;
+    }[] | undefined;
+    storage?: any[] | undefined;
+    routes?: {
+        path: string;
+    }[] | undefined;
+    permissions?: {
+        action: "read" | "write" | "execute" | "admin";
+        scope: "plugin" | "global" | "user";
+        resource: string;
+    }[] | undefined;
+    priority?: number | undefined;
+}>;
+type PluginManifest = z.infer<typeof PluginManifestSchema>;
+type Extension = z.infer<typeof ExtensionSchema>;
+type Dependency = z.infer<typeof DependencySchema>;
+type Entry = z.infer<typeof EntrySchema>;
+type Compatibility = z.infer<typeof CompatibilitySchema>;
+/**
+ * 权限定义
+ * @description 定义插件需要的权限声明
+ */
+interface Permission {
+    /** 权限动作 */
+    action: PermissionAction;
+    /** 权限作用域 */
+    scope: PermissionScope;
+    /** 权限资源标识 */
+    resource: string;
+}
+/** 权限类型 - 权限声明数组 */
+type PermissionType = Permission[];
+/**
+ * 命令处理器类型
+ */
+type CommandHandler = (payload?: any) => void | Promise<void>;
+/**
+ * 命令定义
+ * @description 定义插件可以注册的命令
+ */
+interface Command {
+    /** 命令唯一标识符 */
+    id: string;
+    /** 命令显示名称 */
+    name: string;
+    /** 命令描述 */
+    description?: string;
+    /** 命令参数 Schema */
+    payloadSchema?: z.ZodType<any>;
+    /** 命令处理函数 */
+    handler: CommandHandler;
+}
+/**
+ * 命令类型 (TypeScript 类型)
+ */
+type CommandType = Command;
+/**
+ * 插件激活钩子
+ * @description 插件被激活时调用
+ */
+type OnActivateHandler = (context: PluginContext) => void | Promise<void>;
+/**
+ * 插件停用钩子
+ * @description 插件被停用时调用
+ */
+type OnDeactivateHandler = (context: PluginContext) => void | Promise<void>;
+/**
+ * 插件错误处理钩子
+ * @description 插件发生错误时调用
+ */
+type OnErrorHandler = (error: Error, context: PluginContext) => void;
+/**
+ * 扩展的生命周期钩子类型
+ * @description 扩展插件生命周期管理
+ */
+interface HookType {
+    /**
+     * 插件激活时
+     * @description 插件被激活/启用时触发
+     */
+    onActivate?: OnActivateHandler;
+    /**
+     * 插件停用时
+     * @description 插件被停用/禁用时触发
+     */
+    onDeactivate?: OnDeactivateHandler;
+    /**
+     * 插件错误处理
+     * @description 插件发生错误时触发
+     */
+    onError?: OnErrorHandler;
+}
+
 /**
  * HTTP 请求方法
  */
@@ -24,6 +560,8 @@ interface ApiEndpointConfig {
     responseSchema?: any;
     /** 错误处理策略 */
     errorStrategy?: ErrorStrategy;
+    /** 是否携带凭据 (跨域配置) */
+    withCredentials?: boolean;
 }
 /**
  * API 请求配置
@@ -41,6 +579,8 @@ interface ApiRequestConfig {
     headers?: any;
     /** 用于取消请求的信号对象 */
     signal?: AbortSignal;
+    /** 是否携带凭据 (跨域配置) */
+    withCredentials?: boolean;
 }
 /**
  * 流式响应回调函数接口
@@ -146,26 +686,26 @@ interface EventBusPort {
      * @param callback - 事件触发时的回调函数
      * @returns 取消订阅的函数
      */
-    on(event: string, callback: (...args: any[]) => any): () => void;
+    on(event: string, callback: (...args: unknown[]) => unknown): () => void;
     /**
      * 取消订阅事件
      * @param event - 事件名称
      * @param callback - 之前注册的回调函数
      */
-    off(event: string, callback: (...args: any[]) => any): void;
+    off(event: string, callback: (...args: unknown[]) => unknown): void;
     /**
      * 触发事件 (发布)
      * @param event - 事件名称
      * @param args - 传递给回调函数的参数列表
      */
-    emit(event: string, ...args: any[]): void;
+    emit(event: string, ...args: unknown[]): void;
     /**
      * 订阅一次性事件
      * @description 事件触发一次后会自动取消订阅
      * @param event - 事件名称
      * @param callback - 事件触发时的回调函数
      */
-    once(event: string, callback: (...args: any[]) => any): void;
+    once(event: string, callback: (...args: unknown[]) => unknown): void;
 }
 
 /**
@@ -219,16 +759,23 @@ interface TypedStorage {
 }
 
 /**
- * 插件类型定义
+ * API 端口接口
+ * @description 插件使用 API 能力的入口，包含请求适配器和 API 配置注册功能
  */
-declare const PLUGIN_TYPES: readonly ["business", "functional", "view", "theme", "renderer", "system"];
-type PluginType = typeof PLUGIN_TYPES[number];
+interface ApiPort extends ApiAdapter {
+    /**
+     * 注册 API 配置
+     * @param config - API 配置对象
+     */
+    register?: (config: ApiConfig) => void;
+}
+
 /**
  * 路由配置
  */
 interface RouteConfig {
     path: string;
-    component: React.ComponentType<any>;
+    component: any;
     meta?: Record<string, any>;
 }
 /**
@@ -256,8 +803,8 @@ type SlotPosition = SlotType | string;
 interface PluginExtension {
     /** 插槽位置标识符 */
     slot: SlotPosition;
-    /** 要注入的 React 组件 */
-    component: React.ComponentType<any>;
+    /** 要注入的 React 等框架组件 */
+    component: any;
     /** 排序权重，数值越小越靠前 */
     order?: number;
     /** @internal 插件 ID，由系统在加载时自动注入，用于溯源 */
@@ -265,7 +812,7 @@ interface PluginExtension {
     /** 扩展的元数据信息 */
     meta?: {
         /** 显示图标 */
-        icon?: React.ReactNode;
+        icon?: any;
         /** 显示标签文本 */
         label?: string;
         /** 详细描述 */
@@ -377,26 +924,27 @@ interface PluginStorage extends TypedStorage {
 /**
  * 插件生命周期 Hooks
  * @description 插件可以在不同的生命周期阶段执行特定的逻辑
+ * @template T - 插件清单类型，默认为 PluginManifest
  */
-interface PluginLifecycle {
+interface PluginLifecycle<T extends PluginManifest = PluginManifest> {
     /**
      * 插件加载时调用
      * @description 在插件被扫描并注入内核时触发。用于初始化内部状态、注册服务、设置拦截器等。此时 UI 尚未挂载。
      * @param context - 插件上下文对象，提供核心能力的访问
      */
-    onLoad?: (context: PluginContext) => void | Promise<void>;
+    onLoad?: (context: PluginContext<T>) => void | Promise<void>;
     /**
      * 插件挂载到 UI 时调用
      * @description 当插件的 UI 组件（如有）被 React 挂载到 DOM 时触发。
      * @param context - 插件上下文对象
      */
-    onMount?: (context: PluginContext) => void;
+    onMount?: (context: PluginContext<T>) => void;
     /**
      * 插件从 UI 卸载时调用
      * @description 当插件的 UI 组件被销毁时触发。用于清理定时器、取消订阅等。
      * @param context - 插件上下文对象
      */
-    onUnmount?: (context: PluginContext) => void;
+    onUnmount?: (context: PluginContext<T>) => void;
     /**
      * 插件配置发生变化时调用
      * @description 当用户通过配置中心修改插件设置时触发。
@@ -404,16 +952,26 @@ interface PluginLifecycle {
      * @param oldConfig - 变更前的旧配置对象
      */
     onConfigChange?: (newConfig: any, oldConfig: any) => void;
+    /**
+     * 插件错误处理
+     * @description 当插件发生错误时触发，用于统一错误处理和日志记录
+     * @param error - 错误对象
+     * @param context - 插件上下文对象
+     */
+    onError?: (error: Error, context: PluginContext<T>) => void;
 }
 /**
  * 插件上下文
  * @description 传递给插件生命周期钩子的核心对象，是插件访问宿主环境能力的唯一入口。
+ * @template T - 插件清单类型，默认为 PluginManifest
  */
-interface PluginContext {
+interface PluginContext<T extends PluginManifest = PluginManifest> {
     /** 当前插件的唯一标识符 */
-    pluginId: string;
+    pluginId: PluginId;
+    /** 插件清单 */
+    manifest: T;
     /** API 请求能力入口 */
-    api: any;
+    api: ApiPort;
     /** 事件总线能力入口 */
     events: EventBusPort;
     /** 存储管理能力入口 */
@@ -430,13 +988,13 @@ interface PluginContext {
      * @param serviceName - 服务注册名称
      * @returns 服务实例，如果不存在则返回 undefined
      */
-    getService: <T = any>(serviceName: string) => T | undefined;
+    getService: <T = unknown>(serviceName: string) => T | undefined;
     /**
      * 注册当前插件的服务供他人使用
      * @param serviceName - 唯一服务名称
      * @param service - 服务实现对象
      */
-    registerService: (serviceName: string, service: any) => void;
+    registerService: <T = unknown>(serviceName: string, service: T) => void;
     /** 宿主环境 Window 的代理对象 (用于沙箱隔离) */
     window: WindowProxy;
 }
@@ -452,7 +1010,7 @@ interface Plugin extends PluginLifecycle {
     /** 插件元数据配置 */
     metadata: PluginMetadata;
     /** 插件提供的功能组件集合 (可选) */
-    components?: Record<string, React.ComponentType<any>>;
+    components?: Record<string, any>;
     /** 插件提供的工具函数集合 (可选) */
     utils?: Record<string, any>;
     /** 插件的初始默认配置 (可选) */
@@ -499,8 +1057,8 @@ interface PluginMetadata {
     description?: string;
     /** 插件作者信息 */
     author?: string;
-    /** 插件图标 (React 组件或图标名称) */
-    icon?: React.ReactNode;
+    /** 插件图标 */
+    icon?: any;
     /** 插件依赖的其他插件 ID 列表 */
     dependencies?: string[];
     /** 路由配置集合，用于在主应用中注册页面 */
@@ -515,6 +1073,12 @@ interface PluginMetadata {
     configuration?: PluginConfigItem[];
     /** 插件所需的存储结构定义 */
     storage?: StorageItemSchema[];
+    /**
+     * 插件优先级
+     * @description 数值越小优先级越高，用于插件加载顺序和插槽渲染顺序
+     * @default 100
+     */
+    priority?: number;
     /**
      * 系统状态自动绑定
      * @description 将插件的配置项自动同步到系统的全局状态中 (如主题色、身份认证等)
@@ -530,368 +1094,456 @@ interface PluginMetadata {
 }
 
 /**
- * 基于 Axios 的默认请求适配器
+ * @file template-literals.ts
+ * @description 模板字面量类型 - 用于精确类型检查
  */
-declare class AxiosAdapter implements ApiAdapter {
-    private client;
-    constructor(baseURL?: string, timeout?: number);
-    request<T = any>(config: ApiRequestConfig): Promise<T>;
-    stream(config: ApiRequestConfig, callbacks: StreamCallbacks, _endpointConfig?: ApiEndpointConfig): Promise<void>;
+
+/**
+ * SemVer 版本号类型
+ * @description 匹配符合 SemVer 规范 (^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?$) 的版本号
+ * 支持如 1.0.0, 1.2.3-beta.1, 2.0.0-alpha+001 等格式
+ */
+type SemVer = string & {
+    __semver: 'SemVer';
+};
+/**
+ * RoutePath 路由路径类型
+ * @description 以 / 开头的路由路径
+ */
+type RoutePath = string & {
+    __routePath: 'RoutePath';
+};
+
+/**
+ * SemVer 的 Zod 验证 Schema
+ */
+declare const SemVerSchema: z.ZodString;
+/**
+ * RoutePath 的 Zod 验证 Schema
+ */
+declare const RoutePathSchema: z.ZodString;
+/**
+ * 创建类型安全的 SemVer 版本号
+ * @param version - 版本号字符串
+ * @returns 带类型标记的 SemVer 类型
+ */
+declare function createSemVer(version: string): SemVer;
+/**
+ * 创建类型安全的 RoutePath 路由路径
+ * @param path - 路由路径字符串
+ * @returns 带类型标记的 RoutePath 类型
+ */
+declare function createRoutePath(path: string): RoutePath;
+/**
+ * 类型守卫：检查是否为有效的 SemVer
+ * @param value - 要检查的值
+ * @returns 是否为 SemVer 类型
+ */
+declare function isSemVer(value: unknown): value is SemVer;
+/**
+ * 类型守卫：检查是否为有效的 RoutePath
+ * @param value - 要检查的值
+ * @returns 是否为 RoutePath 类型
+ */
+declare function isRoutePath(value: unknown): value is RoutePath;
+
+/**
+ * 深度只读类型
+ * @description 递归将所有属性（包括嵌套对象和数组）设为只读
+ * @example
+ * type ReadonlyPluginConfig = DeepReadonly<PluginConfig>;
+ * // 所有嵌套属性都变为 readonly
+ */
+type DeepReadonly<T> = {
+    readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
+};
+/**
+ * 配置项定义
+ */
+interface ConfigItemDefinition {
+    key: string;
+    type: 'string' | 'number' | 'boolean' | 'select';
+    label: string;
+    description?: string;
+    default?: unknown;
+    options?: Array<{
+        label: string;
+        value: unknown;
+    }>;
 }
+/**
+ * 安全的插件配置类型
+ * @description 根据插件的 configuration 定义生成运行时配置类型
+ * @example
+ * interface MyPluginConfig {
+ *   apiKey: string;
+ *   maxResults: number;
+ * }
+ * type SafeConfig = SafePluginConfig<{ apiKey: string; maxResults: number }>;
+ */
+type SafePluginConfig<T extends ConfigItemDefinition[]> = {
+    [K in T[number] as K['key']]: K['default'];
+};
+/**
+ * Plugin Manifest 类型
+ * @description 从 Zod Schema 推断出的插件清单类型
+ */
+type PluginManifestType = {
+    id: string;
+    version: string;
+    name: string;
+    entry: string | {
+        url: string;
+        shareScope?: string;
+    };
+    type?: 'business' | 'functional' | 'view' | 'theme' | 'renderer' | 'system';
+    description?: string;
+    author?: string;
+    icon?: string;
+    compatibility?: {
+        minVersion?: string;
+        maxVersion?: string;
+        supportedVersions?: string[];
+    };
+    dependencies?: Array<{
+        id: string;
+        version: string;
+        optional?: boolean;
+    }>;
+    extensions?: Array<{
+        name: string;
+        type: 'slot' | 'hook' | 'command' | 'service';
+        description?: string;
+        slot?: string;
+        config?: Record<string, unknown>;
+        renderMode?: 'replace' | 'append' | 'prepend';
+        condition?: Record<string, unknown>;
+    }>;
+    capabilities?: Record<string, boolean>;
+    configuration?: ConfigItemDefinition[];
+    storage?: unknown[];
+    routes?: Array<{
+        path: string;
+    }>;
+    permissions?: Array<{
+        action: 'read' | 'write' | 'execute' | 'admin';
+        scope: 'plugin' | 'global' | 'user';
+        resource: string;
+    }>;
+    priority?: number;
+};
+/**
+ * 类型守卫: 检查值是否为有效的 PluginManifest
+ * @param value - 要检查的值
+ * @returns 如果值符合 PluginManifestSchema 则返回 true
+ * @example
+ * if (isPluginManifest(data)) {
+ *   console.log(data.name); // TypeScript 知道这是有效的 PluginManifest
+ * }
+ */
+declare function isPluginManifest(value: unknown): value is PluginManifestType;
 
 /**
- * API 引擎核心类
- * @description 负责加载配置并执行请求，支持策略模式切换底层请求实现
+ * 服务注册中心 (Service Registry)
+ * @description 核心应用层服务，作为微内核架构中的“中枢调度员”。
+ * 主要职责：
+ * 1. 服务解耦：允许插件将其内部功能暴露为“服务”，而无需与其他插件产生物理依赖。
+ * 2. 动态发现：提供按名称查找服务的能力，支持服务热插拔。
+ * 3. 依赖协调：通过 `waitFor` 机制解决插件间由于加载顺序导致的初始化依赖问题。
+ *
+ * 建议的服务命名规范: `pluginId.serviceName` (例如: `auth.sessionService`)
  */
-declare class ApiEngine {
-    private adapter;
-    private config;
-    private interceptors;
-    constructor(adapter?: ApiAdapter);
+declare class ServiceRegistry {
+    /** 存储已注册服务的 Map 对象 */
+    private services;
+    /** 存储正在等待特定服务的监听器集合 */
+    private listeners;
     /**
-     * 注册拦截器
+     * 注册一个服务实现
+     * @param name - 唯一的服务名称
+     * @param service - 服务实例或对象
      */
-    registerInterceptor(interceptor: ApiInterceptor): void;
+    register(name: string, service: any): void;
     /**
-     * 移除拦截器
+     * 同步获取服务实例
+     * @template T - 服务类型的泛型
+     * @param name - 服务名称
+     * @returns 服务实例，若不存在则返回 undefined
      */
-    unregisterInterceptor(interceptor: ApiInterceptor): void;
+    get<T = any>(name: string): T | undefined;
     /**
-     * 切换请求适配器
-     * @param adapter 新的适配器实例
+     * 异步等待并获取服务
+     * @description 如果服务尚未注册，将返回一个 Promise，直到该服务被注册时 resolve。
+     * 支持设置超时时间，防止因插件加载失败导致的永久挂起。
+     *
+     * @template T - 服务类型的泛型
+     * @param name - 待等待的服务名称
+     * @param timeout - 超时时间 (毫秒)，默认 10000ms (10秒)。若为 0 则永不超时。
+     * @returns 包含服务实例的 Promise
+     * @throws {Error} 若在规定时间内服务未注册，则抛出超时异常。
      */
-    useAdapter(adapter: ApiAdapter): void;
+    waitFor<T = any>(name: string, timeout?: number): Promise<T>;
     /**
-     * 注册 API 配置
-     * @param config 配置对象
+     * 检查服务是否已注册
+     * @param name - 服务名称
      */
-    register(config: ApiConfig): void;
+    has(name: string): boolean;
     /**
-     * 获取接口配置
+     * 注销特定的服务
+     * @param name - 服务名称
      */
-    getEndpoint(module: string, action: string): ApiEndpointConfig | undefined;
+    unregister(name: string): void;
     /**
-     * 发起 API 请求
-     * @param module 模块名
-     * @param action 动作名
-     * @param data 请求数据 (Body 或 Query)
-     * @param options 请求选项
+     * 清除所有已注册的服务和监听器
+     * @description 通常仅在系统重置或大型热更新时使用。
      */
-    call<T = any>(module: string, action: string, data?: any, options?: RequestOptions): Promise<T>;
+    clear(): void;
+}
+declare const serviceRegistry: ServiceRegistry;
+
+/**
+ * 配置管理器
+ * @description 核心工具类，负责管理应用的全局系统配置以及各插件的初始化业务配置。
+ * 配置数据通常在应用启动时通过 `usePluginLoader` 注入，并作为插件运行时的取值回退来源。
+ */
+declare class ConfigManager<T = Record<string, unknown>> {
+    /** 内部存储配置的 Map 对象 */
+    private config;
     /**
-     * 发起流式请求
-     * @param module 模块名
-     * @param action 动作名
-     * @param data 请求数据
-     * @param options 请求选项
+     * 设置特定的配置项
+     * @param key - 配置键名（如 'system' 或插件 ID）
+     * @param value - 配置内容对象
      */
-    stream(module: string, action: string, data?: any, options?: RequestOptions): Promise<void>;
+    set<K extends keyof T>(key: K, value: T[K]): void;
+    set(key: string, value: unknown): void;
     /**
-     * 准备请求配置，应用 URL 参数替换和请求拦截器
+     * 获取指定的配置项
+     * @param key - 配置键名
+     * @returns 配置内容，若不存在则返回 undefined
      */
-    private prepareRequestConfig;
+    get<K extends keyof T>(key: K): T[K] | undefined;
+    get(key: string): unknown;
     /**
-     * 应用所有请求拦截器
-     */
-    private applyRequestInterceptors;
-    /**
-     * 应用所有响应拦截器
-     * @returns 是否被劫持
-     */
-    private applyResponseInterceptors;
-    /**
-     * 检查 HTTP 状态码
+     * 深度合并配置对象
+     * @description 对配置进行深度合并，嵌套对象会被递归合并而非完全覆盖。
+     * @param config - 待合并的配置对象映射
      */
-    private checkHttpStatus;
+    merge(config: Partial<T> & Record<string, unknown>): void;
     /**
-     * 提取响应数据
+     * 深度合并两个对象
      */
-    private extractResponseData;
+    private deepMerge;
     /**
-     * 处理业务错误
+     * 获取当前存储的所有配置快照
+     * @returns 包含所有配置的普通对象
      */
-    private handleBusinessError;
+    getAll(): T;
     /**
-     * 判断是否为 BaseResponse
+     * 检查配置项是否存在
      */
-    private isBaseResponse;
+    has(key: string): boolean;
     /**
-     * 严格判断是否为 AxiosResponse
+     * 删除指定配置项
      */
-    private isAxiosResponse;
+    delete(key: string): boolean;
     /**
-     * 创建拦截上下文
+     * 清空所有配置
      */
-    private createInterceptorContext;
+    clear(): void;
 }
-declare const apiEngine: ApiEngine;
-
-/**
- * 自动检测是否处于 Mock 模式
- */
-declare function isMockMode(): boolean;
-/**
- * 从文件模块映射中解析 API 配置
- * @description 配合 Vite 的 import.meta.glob 使用，自动匹配定义文件和 Mock 文件
- * @param definitionsMap API 定义文件映射 (import.meta.glob('./modules/*.ts', { eager: true }))
- * @param mocksMap Mock 文件映射 (import.meta.glob('./modules/*.mock.ts', { eager: true }))
- * @param useMock 是否启用 Mock (如果不传，将自动调用 isMockMode())
- * @returns 合并后的 ApiConfig
- */
-declare function resolveApiModules(definitionsMap: Record<string, any>, mocksMap?: Record<string, any>): ApiConfig;
+/** 全局配置管理器单例 */
+declare const configManager: ConfigManager<Record<string, unknown>>;
 
 /**
- * 成功状态码
- */
-declare const SUCCESS_CODE = "000000";
-/**
- * 基础 API 响应接口
- * @template T 响应数据的类型
+ * AI 能力抽象层类型定义
  */
-interface BaseResponse<T = any> {
-    /** 业务状态码 */
-    code: string | number;
-    /** 响应消息提示 */
-    message: string;
-    /** 业务响应数据主体 */
-    data: T;
+interface AIMessage {
+    id: string;
+    role: 'user' | 'assistant' | 'system' | 'tool';
+    content: string;
+    name?: string;
+    toolCallId?: string;
+    toolCalls?: ToolCall[];
+    createdAt?: number;
 }
-/**
- * 业务场景实体接口
- * @description 描述系统中的业务分析场景
- */
-interface Scene {
-    /** 场景唯一标识符 */
+interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+interface ChatOptions {
+    model?: string;
+    temperature?: number;
+    maxTokens?: number;
+    tools?: AITool[];
+    stream?: boolean;
+    systemPrompt?: string;
+}
+interface AIProvider {
+    chat(messages: AIMessage[], options?: ChatOptions): Promise<AIMessage>;
+    stream(messages: AIMessage[], options?: ChatOptions): AsyncIterable<AIChunk>;
+    functionCall(messages: AIMessage[], tools: AITool[], options?: ChatOptions): Promise<FunctionCallResult>;
+}
+interface AIChunk {
+    type: 'content' | 'tool-call' | 'done' | 'error';
+    content?: string;
+    toolCall?: ToolCall;
+    error?: string;
+}
+interface FunctionCallResult {
+    message: AIMessage;
+    toolCalls: ToolCall[];
+}
+interface Session {
     id: string;
-    /** 场景名称 */
     name: string;
-    /** 场景详细描述 */
-    description: string;
-    /** 场景内部代码/标识 */
-    code: string;
-    /** 场景创建者 ID 或名称 */
-    creator: string;
-    /** 创建时间字符串 (ISO 格式) */
-    createTime: string;
-    /** 该场景关联的物理数据表数量 */
-    tableCount: number;
-    /** 该场景关联的知识库数量 */
-    kbCount: number;
-    /** 该场景关联的预设问答对数量 */
-    qaCount: number;
-    /** 场景封面图 URL (可选) */
-    cover?: string;
+    messages: AIMessage[];
+    createdAt: number;
+    updatedAt: number;
+    metadata?: Record<string, unknown>;
 }
-
-interface ApiProviderProps {
-    api: ApiEngine;
-    children: React.ReactNode;
+interface AITool {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    execute: (args: Record<string, unknown>) => Promise<unknown>;
 }
-declare const ApiProvider: React.FC<ApiProviderProps>;
-declare const useApi: () => ApiEngine;
 
 /**
- * 服务注册中心 (Service Registry)
- * @description 核心应用层服务，作为微内核架构中的“中枢调度员”。
- * 主要职责：
- * 1. 服务解耦：允许插件将其内部功能暴露为“服务”，而无需与其他插件产生物理依赖。
- * 2. 动态发现：提供按名称查找服务的能力，支持服务热插拔。
- * 3. 依赖协调：通过 `waitFor` 机制解决插件间由于加载顺序导致的初始化依赖问题。
- *
- * 建议的服务命名规范: `pluginId.serviceName` (例如: `auth.sessionService`)
+ * 工具注册表
+ * 管理 AI 函数的注册和执行
  */
-declare class ServiceRegistry {
-    /** 存储已注册服务的 Map 对象 */
-    private services;
-    /** 存储正在等待特定服务的监听器集合 */
-    private listeners;
-    /**
-     * 注册一个服务实现
-     * @param name - 唯一的服务名称
-     * @param service - 服务实例或对象
-     */
-    register(name: string, service: any): void;
+declare class ToolRegistry {
+    private tools;
     /**
-     * 同步获取服务实例
-     * @template T - 服务类型的泛型
-     * @param name - 服务名称
-     * @returns 服务实例，若不存在则返回 undefined
+     * 注册工具
      */
-    get<T = any>(name: string): T | undefined;
+    register(tool: AITool): void;
     /**
-     * 异步等待并获取服务
-     * @description 如果服务尚未注册，将返回一个 Promise，直到该服务被注册时 resolve。
-     * 支持设置超时时间，防止因插件加载失败导致的永久挂起。
-     *
-     * @template T - 服务类型的泛型
-     * @param name - 待等待的服务名称
-     * @param timeout - 超时时间 (毫秒)，默认 10000ms (10秒)。若为 0 则永不超时。
-     * @returns 包含服务实例的 Promise
-     * @throws {Error} 若在规定时间内服务未注册，则抛出超时异常。
+     * 注销工具
      */
-    waitFor<T = any>(name: string, timeout?: number): Promise<T>;
+    unregister(name: string): void;
     /**
-     * 检查服务是否已注册
-     * @param name - 服务名称
+     * 获取工具
      */
-    has(name: string): boolean;
+    get(name: string): AITool | null;
     /**
-     * 注销特定的服务
-     * @param name - 服务名称
+     * 列出所有工具
      */
-    unregister(name: string): void;
+    list(): AITool[];
     /**
-     * 清除所有已注册的服务和监听器
-     * @description 通常仅在系统重置或大型热更新时使用。
+     * 执行工具
      */
-    clear(): void;
+    execute(name: string, args: Record<string, unknown>): Promise<unknown>;
 }
-declare const serviceRegistry: ServiceRegistry;
 
 /**
- * 配置管理器
- * @description 核心工具类，负责管理应用的全局系统配置以及各插件的初始化业务配置。
- * 配置数据通常在应用启动时通过 `usePluginLoader` 注入，并作为插件运行时的取值回退来源。
+ * Mock AI Provider
+ * 用于演示和测试环境，返回预设的智能回复
  */
-declare class ConfigManager {
-    /** 内部存储配置的 Map 对象 */
-    private config;
+declare class MockAIProvider implements AIProvider {
+    private responses;
     /**
-     * 设置特定的配置项
-     * @param key - 配置键名（如 'system' 或插件 ID）
-     * @param value - 配置内容对象
+     * 生成回复
      */
-    set(key: string, value: any): void;
+    private generateResponse;
     /**
-     * 获取指定的配置项
-     * @param key - 配置键名
-     * @returns 配置内容，若不存在则返回 undefined
+     * 生成唯一 ID
      */
-    get(key: string): any;
+    private generateId;
     /**
-     * 批量合并配置对象
-     * @description 对顶层属性进行浅合并，若属性值为对象则进行一层深度的合并。
-     * @param config - 待合并的配置对象映射
+     * 聊天（非流式）
      */
-    merge(config: Record<string, any>): void;
+    chat(messages: AIMessage[], options?: ChatOptions): Promise<AIMessage>;
     /**
-     * 获取当前存储的所有配置快照
-     * @returns 包含所有配置的普通对象
+     * 流式响应
+     */
+    stream(messages: AIMessage[], options?: ChatOptions): AsyncIterable<AIChunk>;
+    /**
+     * 函数调用
      */
-    getAll(): Record<string, any>;
+    functionCall(messages: AIMessage[], tools: AITool[], options?: ChatOptions): Promise<FunctionCallResult>;
 }
-/** 全局配置管理器单例 */
-declare const configManager: ConfigManager;
 
-/** 插件错误边界组件属性 */
-interface Props {
-    /** 发生错误的插件 ID */
-    pluginId?: string;
-    /** 错误发生时的降级 UI */
-    fallback?: ReactNode;
-    /** 子组件内容 */
-    children: ReactNode;
-    /** 是否静默模式，开启后不显示任何错误 UI，仅记录日志 */
-    silent?: boolean;
-}
-/** 插件错误边界组件状态 */
-interface State {
-    /** 是否捕获到错误 */
-    hasError: boolean;
-    /** 捕获到的错误对象 */
-    error: Error | null;
-}
 /**
- * 插件错误边界组件
- * @description 核心组件，用于捕获子组件渲染过程中的 JavaScript 错误，记录日志并显示降级 UI。
- * 确保单个插件的运行异常不会导致整个主应用或其他插件崩溃。
+ * OpenAI Provider 实现
+ * 支持 chat、stream、functionCall 方法
  */
-declare class PluginErrorBoundary extends Component<Props, State> {
-    constructor(props: Props);
-    /**
-     * 从错误中派生状态
-     * @param error - 捕获到的错误
-     */
-    static getDerivedStateFromError(error: any): State;
-    /**
-     * 捕获到错误后的回调
-     * @param error - 错误对象
-     * @param errorInfo - 错误堆栈信息
-     */
-    componentDidCatch(error: any, errorInfo: ErrorInfo): void;
-    /**
-     * 重置错误状态，尝试重新渲染
-     */
-    handleRetry: () => void;
-    render(): string | number | boolean | Iterable<React.ReactNode> | react_jsx_runtime.JSX.Element | null | undefined;
+declare class OpenAIProvider implements AIProvider {
+    private client;
+    private defaultOptions;
+    constructor(apiKey: string, defaultOptions?: ChatOptions);
+    chat(messages: AIMessage[], options?: ChatOptions): Promise<AIMessage>;
+    stream(messages: AIMessage[], options?: ChatOptions): AsyncIterable<AIChunk>;
+    functionCall(messages: AIMessage[], tools: AITool[], options?: ChatOptions): Promise<FunctionCallResult>;
+    private toOpenAIMessages;
+    private toOpenAITools;
+    private fromOpenAIMessage;
+    private fromOpenAIToolCall;
 }
 
-/** 插件插槽组件属性 */
-interface PluginSlotProps {
-    /** 插槽位置标识，决定渲染哪些插件扩展 */
-    slot: SlotPosition;
-    /** 传递给扩展组件的 Props 对象 */
-    props?: Record<string, any>;
-    /** 自定义容器类名 (Tailwind CSS) */
-    className?: string;
-    /** 自定义容器内联样式 */
-    style?: React.CSSProperties;
-    /**
-     * 自定义渲染函数
-     * @param item - 包含 key、组件和扩展元信息的对象
-     * @param index - 索引位置
-     */
-    renderItem?: (item: {
-        key: string;
-        component: React.ReactNode;
-        extension: PluginExtension;
-    }, index: number) => React.ReactNode;
-    /** 骨架屏组件，当插槽内无插件扩展时显示的占位 UI */
-    skeleton?: React.ReactNode;
-    /** 回退组件，当插槽内无插件扩展时显示的 UI，优先级高于 skeleton */
-    fallback?: React.ReactNode;
+interface SessionStorage {
+    save(sessions: Session[]): void;
+    load(): Session[];
+}
+interface SessionManagerInterface {
+    createSession(name?: string): Session;
+    getSession(id: string): Session | null;
+    listSessions(): Session[];
+    deleteSession(id: string): void;
+    addMessage(sessionId: string, message: AIMessage): void;
+    clearMessages(sessionId: string): void;
 }
-/**
- * 插件插槽组件
- * @description UI 层的核心组件，用于在应用中声明一个“插槽”。
- * 它会自动根据 slot 标识从 PluginManager 中获取所有注册的插件扩展组件并按顺序渲染。
- * 支持订阅插件变更，实现动态热插拔。
- */
-declare const PluginSlot: React.FC<PluginSlotProps>;
 
 /**
- * 通用插槽骨架屏组件集合
- * @description 提供一组预定义的骨架屏 UI，用于在插件加载或插槽内容未准备好时提供更好的用户体验。
- */
-/**
- * 侧边栏图标骨架屏
- * @param expanded - 是否处于展开状态
- */
-declare const SidebarIconSkeleton: React.FC<{
-    expanded?: boolean;
-}>;
-/**
- * 状态栏项骨架屏
- */
-declare const StatusBarItemSkeleton: React.FC;
-/**
- * 头像骨架屏
- */
-declare const AvatarSkeleton: React.FC;
-/**
- * 通用块级骨架屏
- * @param className - 自定义类名
- */
-declare const BlockSkeleton: React.FC<{
-    className?: string;
-}>;
+ * 会话管理器
+ * 提供会话的创建、查询、删除、消息管理等功能
+ */
+declare class SessionManager implements SessionManagerInterface {
+    private sessions;
+    private storage?;
+    constructor(storage?: SessionStorage);
+    createSession(name?: string): Session;
+    getSession(id: string): Session | null;
+    listSessions(): Session[];
+    deleteSession(id: string): void;
+    addMessage(sessionId: string, message: AIMessage): void;
+    clearMessages(sessionId: string): void;
+    private loadFromStorage;
+    private saveToStorage;
+}
+
 /**
- * 自动根据插槽位置匹配骨架屏
+ * LocalStorage 适配器，用于会话持久化
+ * 注意：仅在浏览器环境可用
  */
-declare const SlotSkeletons: React.FC<{
-    slot: string;
-    expanded?: boolean;
-}>;
+declare class SessionLocalStorageAdapter implements SessionStorage {
+    save(sessions: Session[]): void;
+    load(): Session[];
+}
+
+interface AIState {
+    provider: AIProvider | null;
+    setProvider: (provider: AIProvider) => void;
+    sessions: Session[];
+    currentSessionId: string | null;
+    sessionManager: SessionManager;
+    toolRegistry: ToolRegistry;
+    createSession: (name?: string) => Session;
+    selectSession: (id: string) => void;
+    deleteSession: (id: string) => void;
+    addMessage: (message: AIMessage) => void;
+    registerTool: (tool: AITool) => void;
+    unregisterTool: (name: string) => void;
+    sendMessage: (content: string) => Promise<void>;
+    clearCurrentSession: () => void;
+    streamMessage: (content: string, onChunk: (chunk: string) => void) => Promise<void>;
+}
+declare const useAIStore: zustand.UseBoundStore<zustand.StoreApi<AIState>>;
+declare function createAIStore(apiKey: string, defaultModel?: string): void;
 
 /**
  * 插件注册表接口
@@ -930,59 +1582,310 @@ declare const resolvePluginRegistry: (options: {
     rules?: DiscoveryRule[];
 }) => PluginRegistry;
 
-type EventCallback = (...args: any[]) => any;
 /**
- * 事件总线接口
+ * 日志等级枚举
  */
-interface EventBus {
+declare enum LogLevel {
+    /** 调试级别：输出最详尽的信息 */
+    DEBUG = 0,
+    /** 信息级别：输出重要的运行状态 */
+    INFO = 1,
+    /** 警告级别：输出潜在的问题，但不影响运行 */
+    WARN = 2,
+    /** 错误级别：输出严重的运行异常 */
+    ERROR = 3,
+    /** 禁用日志：不输出任何信息 */
+    NONE = 4
+}
+/**
+ * 日志工具类
+ * @description 核心工具类，提供统一的日志输出格式 `[Prefix] Message`。
+ * 支持通过 `LogLevel` 进行全局过滤。
+ * 支持日志缓冲和自动分组，以减少控制台噪音。
+ * 支持浏览器端 CSS 样式和 Node.js 端 ANSI 颜色。
+ */
+declare class Logger {
+    /** 全局静态日志等级，所有实例共享 */
+    private static level;
+    /** 日志缓冲区 */
+    private static buffer;
+    /** 缓冲输出防抖定时器 */
+    private static flushTimer;
+    /** 缓冲时间窗口 (ms) */
+    private static FLUSH_INTERVAL;
+    /** 是否启用缓冲模式 */
+    private static bufferEnabled;
+    /** 是否为浏览器环境 */
+    private static isBrowser;
+    /** 当前实例的业务模块前缀 */
+    private prefix;
+    /** 实例特定的颜色 */
+    private color;
     /**
-     * 订阅事件
-     * @param event 事件名称
-     * @param callback 回调函数
-     * @returns 取消订阅函数
+     * 构造函数
+     * @param prefix - 业务模块前缀，默认为 'App'
      */
-    on(event: string, callback: EventCallback): () => void;
+    constructor(prefix?: string);
     /**
-     * 取消订阅
-     * @param event 事件名称
-     * @param callback 回调函数
+     * 静态方法：设置全局日志输出等级
+     * @param level - 目标日志等级
      */
-    off(event: string, callback: EventCallback): void;
+    static setLevel(level: LogLevel): void;
     /**
-     * 触发事件
-     * @param event 事件名称
-     * @param args 事件参数
+     * 静态方法：启用或禁用日志缓冲
+     * @param enabled - 是否启用
      */
-    emit(event: string, ...args: any[]): void;
+    static setBufferEnabled(enabled: boolean): void;
     /**
-     * 订阅一次性事件
-     * @param event 事件名称
-     * @param callback 回调函数
+     * 静态方法：获取当前全局日志等级
+     * @returns 当前生效的全局日志等级
      */
-    once(event: string, callback: EventCallback): void;
-}
-declare class DefaultEventBus implements EventBus {
-    private listeners;
-    on(event: string, callback: EventCallback): () => void;
-    off(event: string, callback: EventCallback): void;
-    emit(event: string, ...args: any[]): void;
-    once(event: string, callback: EventCallback): void;
-}
-
-/**
- * 核心领域服务：存储管理器
- * @description 统一管理应用内所有的持久化存储资源。
- * 核心功能：
- * 1. 作用域隔离：通过前缀划分 `plugin`、`shared` 和 `system` 三个层级的存储空间。
+    static getLevel(): LogLevel;
+    /**
+     * 格式化输出前缀
+     */
+    private getFormattedPrefix;
+    /**
+     * 生成分组标题参数
+     */
+    private static getGroupTitleArgs;
+    /**
+     * 内部方法：将日志推入缓冲区或直接输出
+     */
+    private log;
+    /**
+     * 静态方法：刷新缓冲区，分组输出日志
+     */
+    static flush(): void;
+    /**
+     * 打印 DEBUG 级别日志
+     */
+    debug(...args: any[]): void;
+    /**
+     * 打印 INFO 级别日志
+     */
+    info(...args: any[]): void;
+    /**
+     * 打印 WARN 级别日志
+     */
+    warn(...args: any[]): void;
+    /**
+     * 打印 ERROR 级别日志
+     */
+    error(...args: any[]): void;
+    /**
+     * 开始一个日志控制台分组
+     */
+    group(label: string, collapsed?: boolean): void;
+    /**
+     * 结束当前日志控制台分组
+     */
+    groupEnd(): void;
+}
+/** 默认 Logger 实例 */
+declare const logger: Logger;
+/**
+ * 创建带特定前缀的 Logger 实例
+ * @param prefix 日志前缀
+ * @returns Logger 实例
+ */
+declare const createLogger: (prefix: string) => Logger;
+
+/**
+ * @file errors.ts
+ * @description Core 层统一错误处理定义
+ */
+
+/**
+ * 核心错误码枚举
+ */
+declare enum CoreErrorCode {
+    UNKNOWN = "1000",
+    NOT_FOUND = "1001",
+    INVALID_PARAMS = "1002",
+    TIMEOUT = "1003",
+    PLUGIN_NOT_FOUND = "2001",
+    PLUGIN_LOAD_FAILED = "2002",
+    PLUGIN_MOUNT_FAILED = "2003",
+    PLUGIN_UNMOUNT_FAILED = "2004",
+    PLUGIN_DEPENDENCY_MISSING = "2005",
+    PLUGIN_CIRCULAR_DEPENDENCY = "2006",
+    PLUGIN_INIT_FAILED = "2007",
+    STORAGE_READ_FAILED = "3001",
+    STORAGE_WRITE_FAILED = "3002",
+    STORAGE_SCHEMA_VIOLATION = "3003",
+    STORAGE_QUOTA_EXCEEDED = "3004",
+    API_REQUEST_FAILED = "4001",
+    API_RESPONSE_INVALID = "4002",
+    API_NETWORK_ERROR = "4003",
+    API_TIMEOUT = "4004",
+    API_UNAUTHORIZED = "4005",
+    SANDBOX_EVAL_FAILED = "5001",
+    SANDBOX_ISOLATION_BREACHED = "5002",
+    SANDBOX_MEMORY_LIMIT = "5003",
+    SERVICE_NOT_FOUND = "6001",
+    SERVICE_REGISTER_FAILED = "6002",
+    SERVICE_WAIT_TIMEOUT = "6003"
+}
+/**
+ * 错误处理策略
+ */
+declare enum CoreErrorStrategy {
+    THROW = "throw",// 抛出异常
+    RESOLVE = "resolve",// 返回默认值
+    REJECT = "reject",// 返回 Promise reject
+    SILENT = "silent"
+}
+/**
+ * 错误处理选项
+ */
+interface ErrorHandlerOptions {
+    code: CoreErrorCode;
+    strategy: CoreErrorStrategy;
+    defaultValue?: any;
+    logger?: ReturnType<typeof createLogger>;
+    context?: Record<string, any>;
+}
+/**
+ * 核心错误类
+ */
+declare class CoreError extends Error {
+    readonly code: CoreErrorCode;
+    readonly originalError?: Error;
+    readonly context?: Record<string, any>;
+    constructor(code: CoreErrorCode, message: string, originalError?: Error, context?: Record<string, any>);
+}
+/**
+ * 统一错误处理函数
+ */
+declare function handleError(error: unknown, options: ErrorHandlerOptions): any;
+
+/**
+ * 成功状态码
+ */
+declare const SUCCESS_CODE = "000000";
+/**
+ * 基础 API 响应接口
+ * @template T 响应数据的类型
+ */
+interface BaseResponse<T = any> {
+    /** 业务状态码 */
+    code: string | number;
+    /** 响应消息提示 */
+    message: string;
+    /** 业务响应数据主体 */
+    data: T;
+}
+/**
+ * 业务场景实体接口
+ * @description 描述系统中的业务分析场景
+ */
+interface Scene {
+    /** 场景唯一标识符 */
+    id: string;
+    /** 场景名称 */
+    name: string;
+    /** 场景详细描述 */
+    description: string;
+    /** 场景内部代码/标识 */
+    code: string;
+    /** 场景创建者 ID 或名称 */
+    creator: string;
+    /** 创建时间字符串 (ISO 格式) */
+    createTime: string;
+    /** 该场景关联的物理数据表数量 */
+    tableCount: number;
+    /** 该场景关联的知识库数量 */
+    kbCount: number;
+    /** 该场景关联的预设问答对数量 */
+    qaCount: number;
+    /** 场景封面图 URL (可选) */
+    cover?: string;
+}
+
+/**
+ * @file performance/types.ts
+ * @description 性能监测数据类型定义
+ * @author ChatBI Team
+ */
+/**
+ * 插件生命周期阶段
+ */
+type LifecyclePhase = 'load' | 'mount' | 'unmount';
+/**
+ * 生命周期性能指标
+ * 记录插件 load/mount/unmount 阶段的执行耗时
+ */
+interface LifecycleMetric {
+    /** 插件 ID */
+    pluginId: string;
+    /** 生命周期阶段 */
+    phase: LifecyclePhase;
+    /** 执行耗时（毫秒） */
+    duration: number;
+    /** 时间戳 */
+    timestamp: number;
+    /** 是否成功 */
+    success: boolean;
+    /** 错误信息（仅在 success 为 false 时存在） */
+    error?: string;
+}
+/**
+ * 运行时性能指标
+ * 记录插件运行期间的内存、帧率等数据
+ */
+interface RuntimeMetric {
+    /** 插件 ID */
+    pluginId: string;
+    /** 时间戳 */
+    timestamp: number;
+    /** 内存使用量（字节） */
+    memory?: number;
+    /** 帧率 */
+    fps?: number;
+    /** API 调用次数 */
+    apiCalls?: number;
+}
+/**
+ * 性能数据集合
+ */
+interface PerformanceData {
+    /** 生命周期指标集合 */
+    lifecycle: LifecycleMetric[];
+    /** 运行时采样数据集合 */
+    samples: RuntimeMetric[];
+}
+/**
+ * 性能监测配置
+ */
+interface PerformanceSettings {
+    /** 生命周期记录最大条数（默认 1000） */
+    maxLifecycleRecords: number;
+    /** 运行时采样最大条数（默认 500） */
+    maxRuntimeSamples: number;
+    /** 采样率（0-1 之间） */
+    sampleRate: number;
+}
+/**
+ * 默认性能监测配置
+ */
+declare const DEFAULT_PERFORMANCE_SETTINGS: PerformanceSettings;
+
+/**
+ * 核心领域服务：存储管理器
+ * @description 统一管理应用内所有的持久化存储资源。
+ * 核心功能：
+ * 1. 作用域隔离：通过前缀划分 `plugin`、`shared` 和 `system` 三个层级的存储空间。
  * 2. Schema 校验：支持注册存储描述，规范数据存取，避免键名冲突。
  * 3. 默认值与配置回退：支持从 Schema 默认值或 ConfigManager 中回退取值。
+ * 4. LRU 缓存：使用 LRU 策略管理内存缓存，防止无限增长。
  */
 declare class StorageManager {
     /** 底层物理存储驱动 */
     private baseStorage;
     /** 插件 ID 与存储描述定义的映射关系 */
     private schemas;
-    /** 内存缓存，减少 JSON 序列化和物理 IO 开销 */
+    /** LRU 内存缓存，减少 JSON 序列化和物理 IO 开销 */
     private memoryCache;
     /**
      * 初始化存储管理器
@@ -1043,221 +1946,151 @@ declare class StorageManager {
 }
 
 /**
- * 插件管理器
- * @description 核心领域服务，负责插件的完整生命周期管理，包括扫描、注册、配置合并、状态切换及依赖解析。
+ * 性能数据存储层
+ * @description 负责性能数据的持久化，支持生命周期指标和运行时采样数据的存储与查询
  */
-declare class PluginManager {
-    /** 全局事件总线，用于插件间及插件与内核间的异步通信 */
-    readonly eventBus: DefaultEventBus;
-    /** 存储管理服务，负责插件私有存储和系统级状态的持久化 */
+declare class PerformanceStorage {
     private storageManager;
-    /** 插件 ID 到运行时实例的映射表 */
-    private runtimes;
-    /** 插件 ID 到原始插件定义对象的映射表 */
-    private plugins;
-    /** 收集到的所有插件路由配置 */
-    private routes;
-    /** 收集到的所有插件扩展点配置，按插槽位置分组 */
-    private extensions;
-    /** 插件的启用状态和排序信息的内存缓存 */
-    private pluginStates;
-    /** 状态变更监听器集合，支持按插槽过滤 */
-    private listeners;
-    /** 按插槽位置存储的监听器，用于精确通知 */
-    private slotListeners;
-    /** 扩展点缓存，避免重复计算 */
-    private memoizedExtensions;
-    /** 路由缓存 */
-    private memoizedRoutes;
-    /** 传递给插件的共享上下文缓存 */
-    private sharedContext;
-    /** 收集到的插件工具函数集合 */
-    private utils;
-    /** 是否正在初始化插件中，防止重入导致多次加载 */
-    private isInitializing;
+    private systemStorage;
+    private settings;
+    private lifecycleCache;
+    private runtimeCache;
+    private readonly LIFECYCLE_KEY;
+    private readonly RUNTIME_KEY;
     /**
      * 构造函数
-     * @param storage - 底层存储适配器
+     * @param storageManager - 存储管理器实例
+     * @param settings - 性能设置（可选，默认使用 DEFAULT_PERFORMANCE_SETTINGS）
      */
-    constructor(storage: StoragePort);
+    constructor(storageManager: StorageManager, settings?: PerformanceSettings);
     /**
-     * 从持久化存储中恢复插件状态 (启用/禁用、排序等)
+     * 从持久化存储加载数据到内存缓存
      */
-    private loadStates;
+    private loadFromStorage;
     /**
-     * 将当前的插件状态持久化到存储中
+     * 保存生命周期指标
+     * @param metric - 生命周期指标
      */
-    private saveStates;
+    saveLifecycleMetric(metric: LifecycleMetric): void;
     /**
-     * 订阅插件状态的变更通知
-     * @param listener - 变更时的回调函数
-     * @param slot - (可选) 指定监听的插槽位置，若提供则仅在该插槽受影响时通知
-     * @returns 取消订阅的函数
+     * 保存运行时指标
+     * @param metric - 运行时指标
      */
-    subscribe(listener: () => void, slot?: SlotPosition | string): () => void;
+    saveRuntimeMetric(metric: RuntimeMetric): void;
     /**
-     * 获取存储管理器实例
-     * @returns StorageManager 实例
+     * 保存指标（通用方法，自动识别类型）
+     * @param metric - 指标数据
      */
-    getStorageManager(): StorageManager;
+    saveMetric(metric: LifecycleMetric | RuntimeMetric): void;
     /**
-     * 触发状态变更通知
-     * @param affectedSlot - (可选) 受影响的插槽位置
+     * 强制执行生命周期数据上限（FIFO）
      */
-    private notify;
+    private enforceLifecycleLimit;
     /**
-     * 获取所有已注册的插件列表
-     * @description 结果会根据插件类型优先级和用户自定义排序进行排序
-     * @returns 排序后的插件数组
+     * 强制执行运行时数据上限（FIFO）
      */
-    getPlugins(): Plugin[];
+    private enforceRuntimeLimit;
     /**
-     * 获取指定插件的状态信息
-     * @param pluginId - 插件 ID
-     * @returns 包含启用状态和排序值的对象
+     * 持久化生命周期数据
      */
-    getPluginState(pluginId: string): {
-        enabled: boolean;
-        order: number;
-    };
+    private persistLifecycle;
     /**
-     * 检查指定插件是否处于启用状态
-     * @param pluginId - 插件 ID
-     * @returns 是否启用
+     * 持久化运行时数据
      */
-    isPluginEnabled(pluginId: string): boolean;
+    private persistRuntime;
     /**
-     * 切换插件的启用/禁用状态
-     * @description 禁用插件会立即触发其卸载生命周期并销毁运行时。
-     * @param pluginId - 插件 ID
-     * @param enabled - 目标状态
+     * 获取生命周期指标
+     * @param pluginId - 插件 ID（可选，不传则返回所有）
      */
-    togglePlugin(pluginId: string, enabled: boolean): void;
+    getLifecycleMetrics(pluginId?: string): LifecycleMetric[];
     /**
-     * 设置插件的显示排序权重
-     * @param pluginId - 插件 ID
-     * @param order - 排序权重值
+     * 获取运行时指标
+     * @param pluginId - 插件 ID（可选，不传则返回所有）
      */
-    setPluginOrder(pluginId: string, order: number): void;
+    getRuntimeMetrics(pluginId?: string): RuntimeMetric[];
     /**
-     * 获取指定插件的运行时状态
-     * @param pluginId - 插件 ID
-     * @returns 'error' | 'mounted' | 'loaded' | 'initial'
+     * 清除性能数据
+     * @param pluginId - 插件 ID（可选，不传则清除所有）
      */
-    getPluginRuntimeStatus(pluginId: string): "error" | "mounted" | "loaded" | "initial";
+    clearMetrics(pluginId?: string): void;
     /**
-     * 获取指定插件的运行时错误
-     * @param pluginId - 插件 ID
-     * @returns Error 对象或 null
+     * 获取所有性能数据
      */
-    getPluginError(pluginId: string): Error | null;
+    getAllData(): PerformanceData;
     /**
-     * 报告插件运行时错误 (通常由 ErrorBoundary 调用)
-     * @param pluginId - 插件 ID
-     * @param error - 错误对象
+     * 获取指定插件的性能数据
      */
-    reportPluginError(pluginId: string, error: Error): void;
+    getPluginData(pluginId: string): PerformanceData;
+}
+
+/**
+ * 性能计时器
+ * @description 用于测量代码块执行耗时，自动计算 duration 并保存到存储
+ */
+declare class PerformanceTimer {
+    private startTime;
+    private phase;
+    private pluginId;
+    private storage;
     /**
-     * 获取插件的完整能力声明
+     * 构造函数
+     * @param phase - 生命周期阶段
      * @param pluginId - 插件 ID
-     * @returns 能力对象
+     * @param storage - 性能存储实例
      */
-    getUnifiedCapabilities(pluginId: string): PluginCapabilities;
+    constructor(phase: LifecyclePhase, pluginId: string, storage: PerformanceStorage);
     /**
-     * 更新指定插件的某项配置
-     * @description 该操作会同步更新内存中的配置、持久化到存储并触发全局事件通知。
-     * @param pluginId - 插件 ID
-     * @param key - 配置键名
-     * @param value - 新的配置值
+     * 开始计时
      */
-    updatePluginConfig(pluginId: string, key: string, value: any): void;
+    start(): void;
     /**
-     * 获取指定插件的某项配置值
-     * @param pluginId - 插件 ID
-     * @param key - 配置键名
-     * @returns 配置值
+     * 结束计时并保存结果
+     * @param success - 是否成功
+     * @param error - 错误信息（可选）
      */
-    getPluginConfig(pluginId: string, key: string): any;
+    end(success: boolean, error?: string): void;
+}
+/**
+ * 性能数据采集器
+ * @description 负责性能数据的采集和记录，提供计时器创建和运行时指标记录功能
+ */
+declare class PerformanceCollector {
+    private storage;
     /**
-     * 获取系统全局配置 (非插件特定)
-     * @param key - 系统配置键名
-     * @returns 配置值
+     * 构造函数
+     * @param storage - 性能存储实例
      */
-    getSystemConfig(key: string): any;
+    constructor(storage: PerformanceStorage);
     /**
-     * 获取由插件注册的服务实例
-     * @template T 服务接口类型
-     * @param name - 服务注册名称
-     * @returns 服务实例或 undefined
+     * 开始测量指定生命周期阶段
+     * @param phase - 生命周期阶段
+     * @param pluginId - 插件 ID
+     * @returns PerformanceTimer 实例
      */
-    getService<T = any>(name: string): T | undefined;
+    startMeasure(phase: LifecyclePhase, pluginId: string): PerformanceTimer;
     /**
-     * 获取指定插槽位置的所有已启用插件的扩展
-     * @param slot - 插槽位置标识
-     * @returns 排序后的扩展配置数组
+     * 记录运行时指标
+     * @param metric - 运行时指标（不包含 timestamp）
      */
-    getExtensions(slot: SlotPosition | string): PluginExtension[];
+    recordRuntimeMetric(metric: Omit<RuntimeMetric, 'timestamp'>): void;
     /**
-     * 获取所有已启用插件注册的路由配置
-     * @returns 增强后的路由配置数组
+     * 获取性能指标
+     * @param pluginId - 插件 ID（可选，不传则返回所有）
      */
-    getRoutes(): RouteConfig[];
-    /**
-     * 注册一个新插件到管理器中
-     * @description 此阶段会执行元数据校验、存储 Schema 注册、配置合并及扩展点收集。
-     * @param plugin - 插件对象
-     * @param notify - 是否在注册完成后触发状态变更通知
-     */
-    register(plugin: Plugin, notify?: boolean): void;
-    /**
-     * 手动挂载指定插件（支持按需加载）
-     * @description 如果插件依赖尚未挂载，会递归挂载所有依赖
-     * @param pluginId 插件 ID
-     */
-    mountPlugin(pluginId: string): Promise<void>;
-    /**
-     * 初始化所有插件
-     * @param sharedContext 共享上下文
-     * @param autoMount 是否自动挂载所有插件 (默认为 false，启用按需加载模式)
-     */
-    initPlugins(sharedContext?: Record<string, any>, autoMount?: boolean): Promise<void>;
-    /**
-     * 获取排序后的插件 ID 列表 (处理依赖)
-     */
-    private getSortedPluginIds;
-    /**
-     * 加载插件列表
-     * @param configs 插件配置
-     * @param registry 插件注册表 (动态导入函数)
-     * @param notify 是否在加载完成后触发通知，默认为 true
-     */
-    loadPlugins(configs: Record<string, any>, registry: Record<string, () => Promise<any>>, notify?: boolean): Promise<void>;
-    /**
-     * 加载远程插件
-     * @param pluginId 插件 ID
-     * @param url 远程 URL
-     * @param config 插件配置
-     */
-    loadRemotePlugin(pluginId: string, url: string, config: any): Promise<Plugin | null>;
+    getMetrics(pluginId?: string): {
+        lifecycle: LifecycleMetric[];
+        runtime: RuntimeMetric[];
+    };
     /**
-     * IIFE 模式加载插件
+     * 清除性能数据
+     * @param pluginId - 插件 ID（可选，不传则清除所有）
      */
-    private loadIIFEPlugin;
+    clearMetrics(pluginId?: string): void;
     /**
-     * 实例化插件
+     * 获取存储实例（供外部使用）
      */
-    private instantiatePlugin;
-    private validatePlugin;
-    private handleBusinessPlugin;
-    private handleFunctionalPlugin;
-    private handleViewPlugin;
-    private handleThemePlugin;
-    private handleSystemPlugin;
+    getStorage(): PerformanceStorage;
 }
-/**
- * 全局插件管理器实例
- */
-declare const pluginManager: PluginManager;
 
 /**
  * @file plugin-runtime.ts
@@ -1291,6 +2124,10 @@ declare class PluginRuntime {
      * @param storageManager - 全局存储管理器
      */
     constructor(plugin: Plugin, sharedContext: Record<string, any>, storageManager: StorageManager);
+    /**
+     * 检查插件是否已完成加载
+     */
+    isLoadedStatus(): boolean;
     /**
      * 执行插件的加载逻辑 (onLoad)
      * @description 此阶段会自动注册插件声明的 API 配置，并调用插件的 onLoad 钩子。
@@ -1330,429 +2167,1608 @@ declare class PluginRuntime {
 }
 
 /**
- * 插件隔离沙箱
- * @description 核心领域服务，为每个插件实例创建独立的运行上下文。
- * 它是插件与系统核心之间的“中间层”，确保插件只能访问其权限范围内的资源。
- * 主要职责：
- * 1. 存储隔离：确保插件只能读写属于自己的 LocalStorage 命名空间。
- * 2. 日志隔离：为插件提供带有自身 ID 前缀的日志输出，方便调试。
+ * 生命周期监测器（装饰器模式）
+ * @description 通过代理模式包装 PluginRuntime，在生命周期各阶段自动记录耗时
  */
-declare class PluginSandbox {
-    /** 关联的插件唯一标识 */
-    private pluginId;
-    /** 系统全局存储管理器 */
-    private storageManager;
+declare class LifecycleMonitor {
+    private runtime;
+    private collector;
     /**
-     * 构造插件沙箱
-     * @param pluginId - 插件 ID
-     * @param storageManager - 系统存储管理器实例
+     * 构造函数
+     * @param runtime - 插件运行时实例
+     * @param collector - 性能采集器实例
      */
-    constructor(pluginId: string, storageManager: StorageManager);
+    constructor(runtime: PluginRuntime, collector: PerformanceCollector);
     /**
-     * 获取隔离的存储接口
-     * @description 返回一个受限的 StoragePort，所有操作都会自动带上插件 ID 前缀。
+     * 包装插件运行时，返回代理对象
+     * @returns 包装后的运行时对象
      */
-    get storage(): {
-        shared: {
-            get: <T = any>(key: string) => T | null;
-            set: <T = any>(key: string, value: T) => void;
-            remove: (key: string) => void;
-        };
-        get: <T = any>(key: string) => T | null;
-        set: <T = any>(key: string, value: T) => void;
-        remove: (key: string) => void;
-    };
+    wrap(): PluginRuntime;
     /**
-     * 获取隔离的日志接口
-     * @description 返回一个带插件 ID 前缀的 Logger 实例。
+     * 包装指定方法，在执行前后记录耗时
+     * @param phase - 生命周期阶段
+     * @param originalMethod - 原始方法
      */
-    get logger(): Logger;
+    private wrapMethod;
 }
+/**
+ * 创建生命周期监测器
+ * @param runtime - 插件运行时实例
+ * @param collector - 性能采集器实例
+ * @returns LifecycleMonitor 实例
+ */
+declare function createLifecycleMonitor(runtime: PluginRuntime, collector: PerformanceCollector): LifecycleMonitor;
 
 /**
- * 浏览器本地存储 (LocalStorage) 适配器
- * @description 实现 `StoragePort` 接口，封装了对原生 `localStorage` 的访问。
- * 支持可选的命名空间前缀隔离，确保在同一个域下不同模块的数据互不干扰。
+ * @file performance/index.ts
+ * @description 性能监测模块统一导出
+ * @author ChatBI Team
  */
-declare class LocalStorageAdapter implements StoragePort {
-    /** 命名空间前缀，所有存入的键名都会自动添加此前缀 */
-    private prefix;
+
+/**
+ * 性能监测系统工厂函数
+ * @param storageManager - 存储管理器实例
+ * @param settings - 性能设置（可选）
+ * @returns 包含 collector, storage, monitor 的对象
+ */
+declare function createPerformanceMonitor(storageManager: StorageManager, settings?: PerformanceSettings): {
+    collector: PerformanceCollector;
+    storage: PerformanceStorage;
+    createMonitor: (runtime: any) => LifecycleMonitor;
+};
+
+declare const PluginEvents: {
+    readonly LOAD: "plugin:load";
+    readonly LOADED: "plugin:loaded";
+    readonly MOUNT: "plugin:mount";
+    readonly MOUNTED: "plugin:mounted";
+    readonly UNMOUNT: "plugin:unmount";
+    readonly LOAD_FAILED: "plugin:load-failed";
+    readonly MOUNT_FAILED: "plugin:mount-failed";
+};
+declare const ConfigEvents: {
+    readonly CHANGE: "config:change";
+};
+/**
+ * 事件回调函数类型
+ * @param T 事件参数类型元组
+ * @returns void
+ */
+type EventCallback<T extends unknown[] = unknown[]> = (...args: T) => void;
+/**
+ * 事件总线接口
+ */
+interface EventBus {
     /**
-     * 初始化适配器
-     * @param prefix - 可选的命名空间前缀（如 'chatbi'），默认为空字符串
+     * 订阅事件
+     * @param event 事件名称
+     * @param callback 回调函数
+     * @returns 取消订阅函数
      */
-    constructor(prefix?: string);
+    on<T extends unknown[]>(event: string, callback: EventCallback<T>): () => void;
     /**
-     * 内部方法：计算实际存储的键名
-     * @param key - 业务层传入的原始键名
-     * @returns 拼接前缀后的物理键名
+     * 取消订阅
+     * @param event 事件名称
+     * @param callback 回调函数
      */
-    private getKey;
+    off<T extends unknown[]>(event: string, callback: EventCallback<T>): void;
     /**
-     * 内部方法：从物理键名还原业务键名
-     * @param namespacedKey - 物理存储中的完整键名
-     * @returns 还原后的原始键名，若前缀不匹配则返回 null
+     * 触发事件
+     * @param event 事件名称
+     * @param args 事件参数
      */
-    private getOriginalKey;
+    emit<T extends unknown[]>(event: string, ...args: T): void;
     /**
-     * 读取存储项
-     * @param key - 原始键名
-     * @returns 存储的字符串内容，不存在则返回 null
+     * 订阅一次性事件
+     * @param event 事件名称
+     * @param callback 回调函数
      */
-    getItem(key: string): string | null;
+    once<T extends unknown[]>(event: string, callback: EventCallback<T>): void;
+}
+declare class DefaultEventBus implements EventBus {
+    private listeners;
+    on<T extends unknown[]>(event: string, callback: EventCallback<T>): () => void;
+    off<T extends unknown[]>(event: string, callback: EventCallback<T>): void;
+    emit<T extends unknown[]>(event: string, ...args: T): void;
+    once<T extends unknown[]>(event: string, callback: EventCallback<T>): void;
+}
+
+/**
+ * 插件错误分类
+ */
+declare enum PluginErrorType {
+    /** 可恢复错误：网络波动、超时等，可以重试 */
+    RECOVERABLE = "recoverable",
+    /** 致命错误：语法错误、循环依赖等，无法通过重试恢复 */
+    FATAL = "fatal",
+    /** 配置错误：插件配置无效 */
+    CONFIG = "config",
+    /** 依赖错误：依赖插件不存在或版本不匹配 */
+    DEPENDENCY = "dependency"
+}
+/**
+ * 插件错误
+ */
+declare class PluginError extends Error {
+    pluginId: string;
+    type: PluginErrorType;
+    originalError?: Error | undefined;
+    retryCount: number;
+    constructor(pluginId: string, type: PluginErrorType, message: string, originalError?: Error | undefined, retryCount?: number);
+}
+/**
+ * 插件管理器
+ * @description 核心领域服务，负责插件的完整生命周期管理，包括扫描、注册、配置合并、状态切换及依赖解析。
+ */
+declare class PluginManager {
+    /** 全局事件总线，用于插件间及插件与内核间的异步通信 */
+    readonly eventBus: DefaultEventBus;
+    /** 存储管理服务，负责插件私有存储和系统级状态的持久化 */
+    private storageManager;
+    /** 插件 ID 到运行时实例的映射表 */
+    private runtimes;
+    /** 插件 ID 到原始插件定义对象的映射表 */
+    private plugins;
+    /** 收集到的所有插件路由配置 */
+    private routes;
+    /** 收集到的所有插件扩展点配置，按插槽位置分组 */
+    private extensions;
+    /** 插件的启用状态和排序信息的内存缓存 */
+    private pluginStates;
+    /** 扩展点缓存，避免重复计算 */
+    private memoizedExtensions;
+    /** 路由缓存 */
+    private memoizedRoutes;
+    /** 传递给插件的共享上下文缓存 */
+    private sharedContext;
+    /** 收集到的插件工具函数集合 */
+    private utils;
+    /** 插件强制启用标记（系统插件不可禁用） */
+    private pluginForces;
+    /** 插件懒加载标记 */
+    private pluginLazyInit;
+    /** 插件默认启用状态 */
+    private pluginDefaultEnabled;
+    /** 是否正在初始化插件中，防止重入导致多次加载 */
+    private isInitializing;
     /**
-     * 写入存储项
-     * @param key - 原始键名
-     * @param value - 待存储的字符串值
+     * 构造函数
+     * @param storage - 底层存储适配器
      */
-    setItem(key: string, value: string): void;
+    constructor(storage: StoragePort);
     /**
-     * 移除特定的存储项
-     * @param key - 原始键名
+     * 从持久化存储中恢复插件状态 (启用/禁用、排序等)
      */
-    removeItem(key: string): void;
+    private loadStates;
     /**
-     * 清空存储空间
-     * @description
-     * - 若定义了前缀：仅删除以该前缀开头的键名，不影响其他数据。
-     * - 若未定义前缀：调用原生 `localStorage.clear()` 清空所有数据。
+     * 将当前的插件状态持久化到存储中
      */
-    clear(): void;
+    private saveStates;
     /**
-     * 返回当前命名空间下的存储项总数
+     * 订阅插件状态变更
+     * @param listener 回调函数，当插件状态变更时被调用
+     * @returns 取消订阅的函数
      */
-    get length(): number;
+    subscribe(listener: () => void): () => void;
     /**
-     * 根据索引获取对应的原始键名
-     * @param index - 索引位置
-     * @returns 对应的业务键名，不存在则返回 null
+     * 订阅路由变更
+     * @param listener 回调函数，当路由变更时被调用
+     * @returns 取消订阅的函数
      */
-    key(index: number): string | null;
-}
-
-/**
- * 作用域存储适配器 (ScopedStorageAdapter)
- * @description 采用装饰器模式实现。它包装一个现有的 `StoragePort` 实例，
- * 并为所有存储操作透明地注入一个前缀（命名空间），从而实现逻辑上的存储隔离。
- * 常用于为插件分配独立的存储空间，而无需修改插件代码。
- */
-declare class ScopedStorageAdapter implements StoragePort {
-    private underlyingStorage;
-    private prefix;
+    subscribeToRoutes(listener: () => void): () => void;
     /**
-     * 初始化作用域适配器
-     * @param underlyingStorage - 被装饰的底层存储适配器实例
-     * @param prefix - 用于隔离的作用域前缀字符串
+     * 获取存储管理器实例
+     * @returns StorageManager 实例
      */
-    constructor(underlyingStorage: StoragePort, prefix: string);
+    getStorageManager(): StorageManager;
     /**
-     * 内部方法：计算实际存储的键名
-     * @param key - 业务层传入的原始键名
-     * @returns 拼接前缀后的物理键名
+     * 用于调度状态更新的函数，可由外部宿主环境（如 React）注入
      */
-    private getKey;
+    private stateUpdateScheduler;
     /**
-     * 内部方法：从物理键名还原业务键名
-     * @param namespacedKey - 物理存储中的完整键名
-     * @returns 还原后的原始键名，若前缀不匹配则返回 null
+     * 注入状态更新调度器
      */
-    private getOriginalKey;
+    setUpdateScheduler(scheduler: (callback: () => void) => void): void;
     /**
-     * 读取当前作用域下的存储项
-     * @param key - 原始键名
-     * @returns 字符串内容，不存在则返回 null
+     * 触发状态变更通知
+     * @description 统一使用 Zustand Store 进行状态管理，EventBus 仅用于一次性事件
+     * @param affectedSlot - (可选) 受影响的插槽位置
      */
-    getItem(key: string): string | null;
+    private notify;
     /**
-     * 写入当前作用域下的存储项
-     * @param key - 原始键名
-     * @param value - 字符串内容
+     * 获取指定插件
+     * @param pluginId 插件 ID
      */
-    setItem(key: string, value: string): void;
+    getPlugin(pluginId: string): Plugin | undefined;
     /**
-     * 移除当前作用域下的特定存储项
-     * @param key - 原始键名
+     * 检查插件是否已注册
+     * @param pluginId - 插件 ID
      */
-    removeItem(key: string): void;
+    hasPlugin(pluginId: string): boolean;
     /**
-     * 清空当前作用域下的所有存储项
-     * @description 仅删除匹配当前前缀的键值对，不会影响底层存储中的其他数据。
+     * 获取指定插件的运行时实例
+     * @param pluginId 插件 ID
+     * @returns 插件运行时实例，如果不存在则返回 undefined
      */
-    clear(): void;
+    getPluginRuntime(pluginId: string): PluginRuntime | undefined;
     /**
-     * 返回当前作用域下的存储项总数
+     * 激活插件
+     * @param pluginId - 插件 ID
      */
-    get length(): number;
+    activate(pluginId: string): Promise<void>;
     /**
-     * 根据索引获取当前作用域下的原始键名
-     * @param index - 索引位置
-     * @returns 对应的业务键名，不存在则返回 null
-     */
-    key(index: number): string | null;
+     * 获取所有已注册的插件列表
+     * @description 结果会根据插件类型优先级和用户自定义排序进行排序
+     * @returns 排序后的插件数组
+     */
+    getPlugins(): Plugin[];
+    /**
+     * 获取指定插件的状态信息
+     * @param pluginId - 插件 ID
+     * @returns 包含启用状态和排序值的对象
+     */
+    getPluginState(pluginId: string): {
+        enabled: boolean;
+        order: number;
+    };
+    /**
+     * 检查指定插件是否处于启用状态
+     * @param pluginId - 插件 ID
+     * @returns 是否启用
+     */
+    isPluginEnabled(pluginId: string): boolean;
+    /**
+     * 检查插件是否可禁用
+     * @param pluginId - 插件 ID
+     * @returns 是否可禁用
+     */
+    canDisablePlugin(pluginId: string): boolean;
+    /**
+     * 检查插件是否应默认启用
+     * @param pluginId - 插件 ID
+     * @returns 是否默认启用
+     */
+    shouldEnableByDefault(pluginId: string): boolean;
+    /**
+     * 切换插件的启用/禁用状态
+     * @description 禁用插件会立即触发其卸载生命周期并销毁运行时。
+     * @param pluginId - 插件 ID
+     * @param enabled - 目标状态
+     */
+    togglePlugin(pluginId: string, enabled: boolean): void;
+    /**
+     * 设置插件的显示排序权重
+     * @param pluginId - 插件 ID
+     * @param order - 排序权重值
+     */
+    setPluginOrder(pluginId: string, order: number): void;
+    /**
+     * 获取指定插件的运行时状态
+     * @param pluginId - 插件 ID
+     * @returns 'error' | 'mounted' | 'loaded' | 'initial'
+     */
+    getPluginRuntimeStatus(pluginId: string): "error" | "mounted" | "loaded" | "initial";
+    /**
+     * 获取指定插件的运行时错误
+     * @param pluginId - 插件 ID
+     * @returns Error 对象或 null
+     */
+    getPluginError(pluginId: string): Error | null;
+    /**
+     * 报告插件运行时错误 (通常由 ErrorBoundary 调用)
+     * @param pluginId - 插件 ID
+     * @param error - 错误对象
+     */
+    reportPluginError(pluginId: string, error: Error): void;
+    /**
+     * 获取插件的完整能力声明
+     * @param pluginId - 插件 ID
+     * @returns 能力对象
+     */
+    getUnifiedCapabilities(pluginId: string): PluginCapabilities;
+    /**
+     * 更新指定插件的某项配置
+     * @description 该操作会同步更新内存中的配置、持久化到存储并触发全局事件通知。
+     * @param pluginId - 插件 ID
+     * @param key - 配置键名
+     * @param value - 新的配置值
+     */
+    updatePluginConfig(pluginId: string, key: string, value: any): void;
+    /**
+     * 获取指定插件的某项配置值
+     * @param pluginId - 插件 ID
+     * @param key - 配置键名
+     * @returns 配置值
+     */
+    getPluginConfig(pluginId: string, key: string): any;
+    /**
+     * 获取系统全局配置 (非插件特定)
+     * @param key - 系统配置键名
+     * @returns 配置值
+     */
+    getSystemConfig(key: string): any;
+    /**
+     * 获取由插件注册的服务实例
+     * @template T 服务接口类型
+     * @param name - 服务注册名称
+     * @returns 服务实例或 undefined
+     */
+    getService<T = any>(name: string): T | undefined;
+    /**
+     * 获取指定插槽位置的所有已启用插件的扩展
+     * @param slot - 插槽位置标识
+     * @returns 排序后的扩展配置数组
+     */
+    getExtensions(slot: SlotPosition | string): PluginExtension[];
+    /**
+     * 获取所有已启用插件注册的路由配置
+     * @returns 增强后的路由配置数组
+     */
+    getRoutes(): RouteConfig[];
+    /**
+     * 注册一个新插件到管理器中
+     * @description 此阶段会执行元数据校验、存储 Schema 注册、配置合并及扩展点收集。
+     * @param plugin - 插件对象
+     * @param notify - 是否在注册完成后触发状态变更通知
+     */
+    register(plugin: Plugin, notify?: boolean): void;
+    /**
+     * 手动挂载指定插件（支持按需加载）
+     * @description 如果插件依赖尚未挂载，会递归挂载所有依赖
+     * @param pluginId 插件 ID
+     */
+    mountPlugin(pluginId: string): Promise<void>;
+    /**
+     * 初始化所有插件
+     * @param sharedContext 共享上下文
+     * @param autoMount 是否自动挂载所有插件 (默认为 false，启用按需加载模式)
+     */
+    initPlugins(sharedContext?: Record<string, any>, autoMount?: boolean): Promise<void>;
+    /**
+     * 带重试机制的插件加载
+     */
+    private loadPluginWithRetry;
+    /**
+     * 带重试机制的插件挂载
+     */
+    private mountPluginWithRetry;
+    /**
+     * 获取排序后的插件 ID 列表 (处理依赖)
+     */
+    private getSortedPluginIds;
+    /**
+     * 加载插件列表
+     * @param configs 插件配置
+     * @param registry 插件注册表 (动态导入函数)
+     * @param notify 是否在加载完成后触发通知，默认为 true
+     */
+    loadPlugins(configs: Record<string, any>, registry: Record<string, () => Promise<any>>, notify?: boolean): Promise<void>;
+    /**
+     * 加载远程插件
+     * @param pluginId 插件 ID
+     * @param url 远程 URL
+     * @param config 插件配置
+     */
+    loadRemotePlugin(pluginId: string, url: string, config: any): Promise<Plugin | null>;
+    /**
+     * IIFE 模式加载插件
+     */
+    private loadIIFEPlugin;
+    /**
+     * 实例化插件
+     */
+    private instantiatePlugin;
+    private validatePlugin;
+    private handleBusinessPlugin;
+    private handleFunctionalPlugin;
+    private handleViewPlugin;
+    private handleThemePlugin;
+    private handleRendererPlugin;
+    private handleSystemPlugin;
+    /**
+     * 注册插件默认配置
+     */
+    private registerDefaultConfig;
+}
+/**
+ * 全局插件管理器实例
+ */
+declare const pluginManager: PluginManager;
+
+/**
+ * 插件隔离沙箱
+ * @description 核心领域服务，为每个插件实例创建独立的运行上下文。
+ * 它是插件与系统核心之间的“中间层”，确保插件只能访问其权限范围内的资源。
+ * 主要职责：
+ * 1. 存储隔离：确保插件只能读写属于自己的 LocalStorage 命名空间。
+ * 2. 日志隔离：为插件提供带有自身 ID 前缀的日志输出，方便调试。
+ */
+declare class PluginSandbox {
+    /** 关联的插件唯一标识 */
+    private pluginId;
+    /** 系统全局存储管理器 */
+    private storageManager;
+    /**
+     * 构造插件沙箱
+     * @param pluginId - 插件 ID
+     * @param storageManager - 系统存储管理器实例
+     */
+    constructor(pluginId: string, storageManager: StorageManager);
+    /**
+     * 获取隔离的存储接口
+     * @description 返回一个受限的 StoragePort，所有操作都会自动带上插件 ID 前缀。
+     */
+    get storage(): {
+        shared: {
+            get: <T = any>(key: string) => T | null;
+            set: <T = any>(key: string, value: T) => void;
+            remove: (key: string) => void;
+        };
+        get: <T = any>(key: string) => T | null;
+        set: <T = any>(key: string, value: T) => void;
+        remove: (key: string) => void;
+    };
+    /**
+     * 获取隔离的日志接口
+     * @description 返回一个带插件 ID 前缀的 Logger 实例。
+     */
+    get logger(): Logger;
+}
+
+/** 特性规则类型 */
+type RuleType = 'environment' | 'user' | 'percentage';
+/** 特性规则 */
+interface FeatureRule {
+    type: RuleType;
+    condition: string;
+    value?: string | number;
+}
+/** 特性配置 */
+interface FeatureConfig {
+    enabled: boolean;
+    rules: FeatureRule[];
+    namespace: string;
+    description?: string;
+}
+/** 迁移警告 */
+interface MigrationWarning {
+    pluginId: string;
+    currentVersion: string;
+    targetVersion: string;
+    steps: string[];
+}
+/** 废弃信息 */
+interface DeprecationInfo {
+    deprecatedIn: string;
+    willRemoveIn: string;
+    message: string;
+}
+/** 废弃警告 */
+interface DeprecationWarning {
+    feature: string;
+    info: DeprecationInfo;
+}
+declare const FEATURE_NAMESPACE_PREFIX = "chatbi:feature:";
+declare const STORAGE_KEY = "chatbi:feature:store";
+interface FeatureRegistryState {
+    features: Record<string, FeatureConfig>;
+    migrationPaths: Record<string, {
+        toVersion: string;
+        steps: string[];
+    }>;
+    deprecatedFeatures: Record<string, DeprecationInfo>;
+    setFeature: (name: string, config: Partial<FeatureConfig>) => void;
+    getFeature: (name: string) => FeatureConfig | undefined;
+    removeFeature: (name: string) => void;
+    isEnabled: (name: string, context?: {
+        userId?: string;
+        env?: string;
+    }) => boolean;
+    addMigrationPath: (fromVersion: string, toVersion: string, steps: string[]) => void;
+    checkMigration: (plugins: PluginManifest[]) => MigrationWarning[];
+    registerDeprecation: (feature: string, info: DeprecationInfo) => void;
+    checkDeprecations: (features?: string[]) => DeprecationWarning[];
+}
+declare function simpleHash$1(str: string): number;
+declare function evaluateRules$1(rules: FeatureRule[], context: {
+    userId?: string;
+    env?: string;
+}): boolean;
+declare const useFeatureFlags: zustand.UseBoundStore<Omit<zustand.StoreApi<FeatureRegistryState>, "setState" | "persist"> & {
+    setState(partial: FeatureRegistryState | Partial<FeatureRegistryState> | ((state: FeatureRegistryState) => FeatureRegistryState | Partial<FeatureRegistryState>), replace?: false | undefined): unknown;
+    setState(state: FeatureRegistryState | ((state: FeatureRegistryState) => FeatureRegistryState), replace: true): unknown;
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<FeatureRegistryState, unknown, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: FeatureRegistryState) => void) => () => void;
+        onFinishHydration: (fn: (state: FeatureRegistryState) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<FeatureRegistryState, unknown, unknown>>;
+    };
+}>;
+
+/**
+ * 规则引擎
+ * @description 提供特性规则的评估能力，支持环境、用户和百分比规则
+ */
+
+declare function simpleHash(str: string): number;
+/** 规则评估上下文 */
+interface RuleContext {
+    userId?: string;
+    env?: string;
+    [key: string]: string | undefined;
+}
+/**
+ * 评估规则列表
+ * @param rules 规则数组
+ * @param context 评估上下文
+ * @returns 任意规则匹配返回 true，否则返回 false
+ */
+declare function evaluateRules(rules: FeatureRule[], context: RuleContext): boolean;
+/**
+ * 评估单条规则
+ * @param rule 规则
+ * @param context 评估上下文
+ * @returns 规则是否匹配
+ */
+declare function evaluateRule(rule: FeatureRule, context: RuleContext): boolean;
+/**
+ * 创建百分比规则
+ * @param percentage 百分比值 (0-100)
+ * @returns 百分比规则
+ */
+declare function createPercentageRule(percentage: number): FeatureRule;
+/**
+ * 创环境规则
+ * @param env 环境名称
+ * @returns 环境规则
+ */
+declare function createEnvironmentRule(env: string): FeatureRule;
+/**
+ * 创建用户规则
+ * @param userId 用户 ID
+ * @returns 用户规则
+ */
+declare function createUserRule(userId: string): FeatureRule;
+
+interface UseFeatureResult {
+    isEnabled: boolean;
+    config: FeatureConfig | undefined;
+}
+/**
+ * 特性门控 Hook
+ * @param flagName 特性名称
+ * @param context 评估上下文
+ * @returns 特性状态和配置
+ */
+declare function useFeature(flagName: string, context?: RuleContext): UseFeatureResult;
+
+/**
+ * 验证结果类型
+ */
+interface ValidationResult {
+    /** 是否有效 */
+    valid: boolean;
+    /** 验证通过时的数据 */
+    data?: PluginManifest;
+    /** 验证失败时的错误 */
+    errors?: {
+        /** 错误消息 */
+        message: string;
+        /** 错误路径 */
+        path: string[];
+        /** 具体错误类型 */
+        type: string;
+    }[];
+}
+/**
+ * 验证 Manifest
+ * @param raw - 待验证的原始数据
+ * @returns 验证结果
+ */
+declare function validateManifest(raw: unknown): ValidationResult;
+/**
+ * 验证 Manifest 并抛出错误
+ * @param raw - 待验证的原始数据
+ * @returns 验证通过的 Manifest 数据
+ * @throws ZodError 当验证失败时
+ */
+declare function assertManifest(raw: unknown): PluginManifest;
+
+/**
+ * Manifest 向后兼容包装器
+ * @description 支持旧版 definePlugin 格式自动转换为 Manifest 格式
+ */
+
+/**
+ * 从 Plugin 对象提取 Manifest
+ * @param plugin - 插件对象
+ * @returns 提取的 Manifest 对象
+ */
+declare function extractManifestFromPlugin(plugin: Plugin | Record<string, unknown>): Partial<PluginManifest>;
+/**
+ * 规范化插件 Manifest
+ * @param input - Plugin 对象、definePlugin 结果或纯对象
+ * @returns 规范化后的 Manifest
+ * @throws 当输入无效且无法转换时
+ */
+declare function normalizePluginManifest(input: Plugin | Record<string, unknown> | unknown): ValidationResult;
+
+/**
+ * 核心状态 Store 接口
+ */
+interface CoreState {
+    /** 插件列表变更版本号，用于触发插件管理器的列表更新 */
+    pluginVersion: number;
+    /** 扩展点变更版本号（按插槽），用于实现插槽级别的精确更新 */
+    slotVersions: Record<string, number>;
+    /** 路由变更版本号 */
+    routeVersion: number;
+    /** 触发全局插件列表更新 */
+    notifyPluginsChanged: () => void;
+    /** 触发特定插槽的更新 */
+    notifySlotChanged: (slot: SlotPosition | string) => void;
+    /** 触发路由配置更新 */
+    notifyRoutesChanged: () => void;
+}
+/**
+ * 创建 Vanilla Store 实例
+ */
+declare const coreStore: zustand.StoreApi<CoreState>;
+declare const coreStoreApi: zustand.StoreApi<CoreState>;
+
+/**
+ * 浏览器本地存储 (LocalStorage) 适配器
+ * @description 实现 `StoragePort` 接口，封装了对原生 `localStorage` 的访问。
+ * 支持可选的命名空间前缀隔离，确保在同一个域下不同模块的数据互不干扰。
+ */
+declare class LocalStorageAdapter implements StoragePort {
+    /** 命名空间前缀，所有存入的键名都会自动添加此前缀 */
+    private prefix;
+    /**
+     * 初始化适配器
+     * @param prefix - 可选的命名空间前缀（如 'chatbi'），默认为空字符串
+     */
+    constructor(prefix?: string);
+    /**
+     * 内部方法：计算实际存储的键名
+     * @param key - 业务层传入的原始键名
+     * @returns 拼接前缀后的物理键名
+     */
+    private getKey;
+    /**
+     * 内部方法：从物理键名还原业务键名
+     * @param namespacedKey - 物理存储中的完整键名
+     * @returns 还原后的原始键名，若前缀不匹配则返回 null
+     */
+    private getOriginalKey;
+    /**
+     * 读取存储项
+     * @param key - 原始键名
+     * @returns 存储的字符串内容，不存在则返回 null
+     */
+    getItem(key: string): string | null;
+    /**
+     * 写入存储项
+     * @param key - 原始键名
+     * @param value - 待存储的字符串值
+     */
+    setItem(key: string, value: string): void;
+    /**
+     * 移除特定的存储项
+     * @param key - 原始键名
+     */
+    removeItem(key: string): void;
+    /**
+     * 清空存储空间
+     * @description
+     * - 若定义了前缀：仅删除以该前缀开头的键名，不影响其他数据。
+     * - 若未定义前缀：调用原生 `localStorage.clear()` 清空所有数据。
+     */
+    clear(): void;
+    /**
+     * 返回当前命名空间下的存储项总数
+     */
+    get length(): number;
+    /**
+     * 根据索引获取对应的原始键名
+     * @param index - 索引位置
+     * @returns 对应的业务键名，不存在则返回 null
+     */
+    key(index: number): string | null;
+}
+
+/**
+ * 作用域存储适配器 (ScopedStorageAdapter)
+ * @description 采用装饰器模式实现。它包装一个现有的 `StoragePort` 实例，
+ * 并为所有存储操作透明地注入一个前缀（命名空间），从而实现逻辑上的存储隔离。
+ * 常用于为插件分配独立的存储空间，而无需修改插件代码。
+ */
+declare class ScopedStorageAdapter implements StoragePort {
+    private underlyingStorage;
+    private prefix;
+    /**
+     * 初始化作用域适配器
+     * @param underlyingStorage - 被装饰的底层存储适配器实例
+     * @param prefix - 用于隔离的作用域前缀字符串
+     */
+    constructor(underlyingStorage: StoragePort, prefix: string);
+    /**
+     * 内部方法：计算实际存储的键名
+     * @param key - 业务层传入的原始键名
+     * @returns 拼接前缀后的物理键名
+     */
+    private getKey;
+    /**
+     * 内部方法：从物理键名还原业务键名
+     * @param namespacedKey - 物理存储中的完整键名
+     * @returns 还原后的原始键名，若前缀不匹配则返回 null
+     */
+    private getOriginalKey;
+    /**
+     * 读取当前作用域下的存储项
+     * @param key - 原始键名
+     * @returns 字符串内容，不存在则返回 null
+     */
+    getItem(key: string): string | null;
+    /**
+     * 写入当前作用域下的存储项
+     * @param key - 原始键名
+     * @param value - 字符串内容
+     */
+    setItem(key: string, value: string): void;
+    /**
+     * 移除当前作用域下的特定存储项
+     * @param key - 原始键名
+     */
+    removeItem(key: string): void;
+    /**
+     * 清空当前作用域下的所有存储项
+     * @description 仅删除匹配当前前缀的键值对，不会影响底层存储中的其他数据。
+     */
+    clear(): void;
+    /**
+     * 返回当前作用域下的存储项总数
+     */
+    get length(): number;
+    /**
+     * 根据索引获取当前作用域下的原始键名
+     * @param index - 索引位置
+     * @returns 对应的业务键名，不存在则返回 null
+     */
+    key(index: number): string | null;
+}
+
+/**
+ * 基于 Axios 的默认请求适配器
+ */
+declare class AxiosAdapter implements ApiAdapter {
+    private client;
+    constructor(baseURL?: string, timeout?: number);
+    request<T = any>(config: ApiRequestConfig): Promise<T>;
+    stream(config: ApiRequestConfig, callbacks: StreamCallbacks, _endpointConfig?: ApiEndpointConfig): Promise<void>;
+}
+
+/**
+ * API 引擎核心类
+ * @description 负责加载配置并执行请求，支持策略模式切换底层请求实现
+ */
+declare class ApiEngine {
+    private adapter;
+    private config;
+    private interceptors;
+    /** 可配置的成功码 */
+    private successCodes;
+    constructor(adapter?: ApiAdapter);
+    /**
+     * 注册拦截器
+     */
+    registerInterceptor(interceptor: ApiInterceptor): void;
+    /**
+     * 移除拦截器
+     */
+    unregisterInterceptor(interceptor: ApiInterceptor): void;
+    /**
+     * 设置成功码
+     */
+    setSuccessCodes(codes: string[]): void;
+    /**
+     * 切换请求适配器
+     * @param adapter 新的适配器实例
+     */
+    useAdapter(adapter: ApiAdapter): void;
+    /**
+     * 注册 API 配置
+     * @param config 配置对象
+     */
+    register(config: ApiConfig): void;
+    /**
+     * 获取接口配置
+     */
+    getEndpoint(module: string, action: string): ApiEndpointConfig | undefined;
+    /**
+     * 发起 API 请求
+     * @param module 模块名
+     * @param action 动作名
+     * @param data 请求数据 (Body 或 Query)
+     * @param options 请求选项
+     */
+    call<T = any>(module: string, action: string, data?: any, options?: RequestOptions): Promise<T>;
+    /**
+     * 发起流式请求
+     * @param module 模块名
+     * @param action 动作名
+     * @param data 请求数据
+     * @param options 请求选项
+     */
+    stream(module: string, action: string, data?: any, options?: RequestOptions): Promise<void>;
+    /**
+     * 准备请求配置，应用 URL 参数替换和请求拦截器
+     */
+    private prepareRequestConfig;
+    /**
+     * 应用所有请求拦截器
+     */
+    private applyRequestInterceptors;
+    /**
+     * 应用所有响应拦截器
+     * @returns 是否被劫持
+     */
+    private applyResponseInterceptors;
+    /**
+     * 检查 HTTP 状态码
+     */
+    private checkHttpStatus;
+    /**
+     * 提取响应数据
+     */
+    private extractResponseData;
+    /**
+     * 处理业务错误
+     */
+    private handleBusinessError;
+    /**
+     * 检查响应是否成功
+     */
+    protected isSuccess(response: any): boolean;
+    /**
+     * 处理响应错误
+     */
+    protected handleResponseError(response: any, context: any): void;
+    /**
+     * 判断是否为 BaseResponse
+     */
+    private isBaseResponse;
+    /**
+     * 严格判断是否为 AxiosResponse
+     */
+    private isAxiosResponse;
+    /**
+     * 创建拦截上下文
+     */
+    private createInterceptorContext;
+}
+declare const apiEngine: ApiEngine;
+
+/**
+ * 自动检测是否处于 Mock 模式
+ */
+declare function isMockMode(): boolean;
+/**
+ * 从文件模块映射中解析 API 配置
+ * @description 配合 Vite 的 import.meta.glob 使用，自动匹配定义文件和 Mock 文件
+ * @param definitionsMap API 定义文件映射 (import.meta.glob('./modules/*.ts', { eager: true }))
+ * @param mocksMap Mock 文件映射 (import.meta.glob('./modules/*.mock.ts', { eager: true }))
+ * @param useMock 是否启用 Mock (如果不传，将自动调用 isMockMode())
+ * @returns 合并后的 ApiConfig
+ */
+declare function resolveApiModules(definitionsMap: Record<string, any>, mocksMap?: Record<string, any>): ApiConfig;
+
+/**
+ * 沙箱选项
+ */
+interface SandboxOptions {
+    /** 严格模式：启用所有安全限制 */
+    strict?: boolean;
+    /** 自定义白名单 */
+    customWhitelist?: Record<string, boolean>;
+    /** 是否允许 DOM 访问 */
+    allowDOM?: boolean;
+    /** 是否允许网络请求 */
+    allowNetwork?: boolean;
+}
+/**
+ * ProxySandbox 类
+ * @description 基于 Proxy 的 JS 沙箱实现，模拟独立的 Window 环境
+ */
+declare class ProxySandbox {
+    /** 沙箱名称 */
+    name: string;
+    /** 代理后的 Window 对象 */
+    proxy: WindowProxy;
+    /** 沙箱是否激活 */
+    running: boolean;
+    /** 沙箱选项 */
+    private options;
+    /** 记录新增/修改的全局变量 */
+    private updatedValueSet;
+    /** 绑定函数的缓存池，避免重复 bind 带来的性能开销 */
+    private boundFunctionCache;
+    /** 副作用记录池 */
+    private effectPool;
+    /** 真实的 Window 对象 */
+    private globalContext;
+    /** 白名单全局变量（允许透传访问真实 Window） */
+    private static globalWhitelist;
+    constructor(name: string, options?: SandboxOptions, globalContext?: Window & typeof globalThis);
+    /**
+     * 激活沙箱
+     */
+    active(): void;
+    /**
+     * 销毁沙箱
+     */
+    inactive(): void;
+    /**
+     * 获取缓存的绑定函数，避免重复 bind
+     */
+    getBoundFunction(fn: Function, context: Window): Function;
+    /**
+     * 获取当前缓存大小（用于监控和调试）
+     */
+    getCacheSize(): number;
+    /**
+     * 在沙箱中执行代码
+     * @param code JS 代码字符串
+     * @param options 执行选项
+     * @returns 执行结果
+     * @description 使用 IIFE 模式执行代码，替代已废弃的 with 语句
+     */
+    eval(code: string, options?: {
+        useStrict?: boolean;
+    }): any;
+    /**
+     * 创建伪造的 Window 对象
+     */
+    private createFakeWindow;
+    private isConstructor;
+    private isNativeFunction;
+    /**
+     * 劫持全局副作用 API
+     */
+    private patchGlobalEffects;
+}
+
+/**
+ * 日期时间格式化工具类
+ */
+declare const dateUtils: {
+    /**
+     * 格式化日期为 YYYY-MM-DD
+     */
+    formatDate(date?: dayjs.ConfigType): string;
+    /**
+     * 格式化时间为 HH:mm:ss
+     */
+    formatTime(date?: dayjs.ConfigType): string;
+    /**
+     * 格式化日期时间为 YYYY-MM-DD HH:mm:ss
+     */
+    formatDateTime(date?: dayjs.ConfigType): string;
+    /**
+     * 获取当前时间戳（毫秒）
+     */
+    now(): number;
+    /**
+     * 获取相对时间（例如：几分钟前）
+     */
+    fromNow(date: dayjs.ConfigType): string;
+    /**
+     * 原始 dayjs 对象，用于更复杂的场景
+     */
+    dayjs: typeof dayjs;
+};
+
+type KeepStrategy = 'first' | 'last' | 'search' | 'hash';
+/**
+ * 把当前地址中所有出现的参数合并成一份。
+ * 重复 key 的处理策略：
+ *  - 'first'  : 按出现顺序，第一次的值生效
+ *  - 'last'   : 按出现顺序，最后一次的值生效（默认，最直观）
+ *  - 'search' : 只要 search 里出现过，就用 search 的
+ *  - 'hash'   : 只要 hash 里出现过，就用 hash 的
+ */
+declare function normalizeParams(strategy?: KeepStrategy): URLSearchParams;
+/**
+ * 清除 URL 中的特定参数并返回新的 URL
+ * @description 同时处理 search 和 hash 中的参数
+ */
+declare function cleanUrlParams(keysToRemove: string[]): string;
+
+declare const version = "1.0.0";
+
+/**
+ * Remote Plugin Source 类型定义
+ * @description 定义远程插件源接口和配置选项
+ */
+/**
+ * 远程插件源
+ * @description 表示一个远程插件仓库地址
+ */
+interface RemotePluginSource {
+    /** 唯一标识符 */
+    id: string;
+    /** 显示名称 */
+    name: string;
+    /** plugin.json URL */
+    url: string;
+    /** 是否启用 */
+    enabled?: boolean;
+}
+/**
+ * 缓存配置选项
+ */
+interface CacheOptions {
+    /** 缓存 TTL (毫秒)，默认 5 分钟 */
+    ttl: number;
+    /** 最大缓存条目数 */
+    maxSize?: number;
 }
-
-interface PluginProviderProps {
-    manager: PluginManager;
-    children: React.ReactNode;
+/**
+ * 重试配置选项
+ */
+interface RetryOptions {
+    /** 最大重试次数 */
+    maxRetries: number;
+    /** 重试延迟 (毫秒) */
+    retryDelay: number;
+    /** 自定义重试条件 */
+    retryCondition?: (error: any) => boolean;
+}
+/**
+ * 远程源配置选项
+ */
+interface RemoteSourceOptions {
+    /** 请求超时 (毫秒) */
+    timeout?: number;
+    /** 重试配置 */
+    retry?: RetryOptions;
+    /** 缓存配置 */
+    cache?: CacheOptions;
+}
+/**
+ * 缓存条目元数据
+ */
+interface CacheEntry<T = any> {
+    /** 缓存数据 */
+    data: T;
+    /** 创建时间戳 */
+    createdAt: number;
+    /** 最后访问时间戳 */
+    lastAccessedAt: number;
+    /** 过期时间戳 */
+    expiresAt: number;
+}
+/**
+ * 加载结果
+ */
+interface LoadResult<T = any> {
+    /** 是否成功 */
+    success: boolean;
+    /** 加载的数据 */
+    data?: T;
+    /** 加载错误 */
+    error?: LoadError;
+    /** 是否来自缓存 */
+    fromCache?: boolean;
+}
+/**
+ * 加载错误
+ */
+interface LoadError {
+    /** 错误代码 */
+    code: 'NETWORK' | 'TIMEOUT' | 'PARSE' | 'NOT_FOUND' | 'CACHE_ERROR' | 'VALIDATION_ERROR';
+    /** 错误消息 */
+    message: string;
+    /** 是否可重试 */
+    retryable: boolean;
+    /** 原始错误 */
+    originalError?: any;
 }
-declare const PluginProvider: React.FC<PluginProviderProps>;
-declare const usePluginManager: () => PluginManager;
 
 /**
- * ProxySandbox 类
- * @description 基于 Proxy 的 JS 沙箱实现，模拟独立的 Window 环境
+ * 远程缓存管理器
+ * @description 管理远程插件Manifest的缓存，支持TTL和大小限制
  */
-declare class ProxySandbox {
-    /** 沙箱名称 */
-    name: string;
-    /** 代理后的 Window 对象 */
-    proxy: WindowProxy;
-    /** 沙箱是否激活 */
-    running: boolean;
-    /** 记录新增/修改的全局变量 */
-    private updatedValueSet;
-    /** 绑定函数的缓存池，避免重复 bind 带来的性能开销 */
-    private boundFunctionCache;
-    /** 副作用记录池 */
-    private effectPool;
-    /** 真实的 Window 对象 */
-    private globalContext;
-    /** 白名单全局变量（允许透传访问真实 Window） */
-    private static globalWhitelist;
-    constructor(name: string, globalContext?: Window & typeof globalThis);
+declare class RemoteCache<T = any> {
+    private cache;
+    private defaultTtl;
     /**
-     * 激活沙箱
+     * 创建远程缓存管理器
+     * @param options 缓存配置选项
      */
-    active(): void;
+    constructor(options?: CacheOptions);
     /**
-     * 销毁沙箱
+     * 获取缓存条目
+     * @param key 缓存键
+     * @returns 缓存条目，如果不存在或已过期返回 undefined
      */
-    inactive(): void;
+    get(key: string): CacheEntry<T> | undefined;
     /**
-     * 在沙箱中执行代码
-     * @param code JS 代码字符串
-     * @returns 执行结果
+     * 设置缓存条目
+     * @param key 缓存键
+     * @param data 要缓存的数据
+     * @param ttl 自定义 TTL (毫秒)，使用默认 TTL 如果未指定
      */
-    eval(code: string): any;
+    set(key: string, data: T, ttl?: number): void;
     /**
-     * 创建伪造的 Window 对象
+     * 删除缓存条目
+     * @param key 缓存键
+     * @returns 是否成功删除
      */
-    private createFakeWindow;
-    private isConstructor;
-    private isNativeFunction;
+    delete(key: string): boolean;
     /**
-     * 劫持全局副作用 API
+     * 清空所有缓存
      */
-    private patchGlobalEffects;
+    clear(): void;
+    /**
+     * 检查缓存键是否存在
+     * @param key 缓存键
+     */
+    has(key: string): boolean;
+    /**
+     * 获取缓存条目数量
+     */
+    size(): number;
+    /**
+     * 获取缓存条目的元数据（不触发访问时间更新）
+     * @param key 缓存键
+     */
+    getMetadata(key: string): CacheEntry<T> | undefined;
+    /**
+     * 更新缓存 TTL
+     * @param key 缓存键
+     * @param ttl 新 TTL (毫秒)
+     */
+    updateTTL(key: string, ttl: number): boolean;
 }
 
 /**
- * 日期时间格式化工具类
+ * 远程插件加载器
+ * @description 管理远程插件源的添加、移除和 Manifest 加载
  */
-declare const dateUtils: {
+declare class RemoteLoader {
+    private sources;
+    private cache;
+    private retryStrategy;
+    private options;
     /**
-     * 格式化日期为 YYYY-MM-DD
+     * 创建远程加载器
+     * @param options 远程源配置选项
      */
-    formatDate(date?: dayjs.ConfigType): string;
+    constructor(options?: RemoteSourceOptions);
     /**
-     * 格式化时间为 HH:mm:ss
+     * 添加远程插件源
+     * @param source 远程插件源
      */
-    formatTime(date?: dayjs.ConfigType): string;
+    addSource(source: RemotePluginSource): void;
     /**
-     * 格式化日期时间为 YYYY-MM-DD HH:mm:ss
+     * 移除远程插件源
+     * @param sourceId 插件源 ID
+     * @returns 是否成功移除
      */
-    formatDateTime(date?: dayjs.ConfigType): string;
+    removeSource(sourceId: string): boolean;
     /**
-     * 获取当前时间戳（毫秒）
+     * 获取所有远程插件源
+     * @returns 远程插件源列表
      */
-    now(): number;
+    getSources(): RemotePluginSource[];
     /**
-     * 获取相对时间（例如：几分钟前）
+     * 获取指定远程插件源
+     * @param sourceId 插件源 ID
      */
-    fromNow(date: dayjs.ConfigType): string;
+    getSource(sourceId: string): RemotePluginSource | undefined;
     /**
-     * 原始 dayjs 对象，用于更复杂的场景
+     * 启用/禁用远程插件源
+     * @param sourceId 插件源 ID
+     * @param enabled 是否启用
      */
-    dayjs: typeof dayjs;
-};
+    setSourceEnabled(sourceId: string, enabled: boolean): boolean;
+    /**
+     * 从远程加载插件 Manifest
+     * @param sourceId 插件源 ID
+     * @returns 加载结果
+     */
+    loadManifest<T = PluginManifest>(sourceId: string): Promise<LoadResult<T>>;
+    /**
+     * 带重试的请求
+     * @param url 请求 URL
+     * @param attempt 当前尝试次数
+     * @returns 响应数据
+     */
+    private fetchWithRetry;
+    /**
+     * 处理加载错误
+     * @param error 错误对象
+     * @returns 错误结果
+     */
+    private handleLoadError;
+    /**
+     * 创建错误结果
+     * @param code 错误代码
+     * @param message 错误消息
+     * @param retryable 是否可重试
+     * @returns 错误结果
+     */
+    private createErrorResult;
+    /**
+     * 清除缓存
+     * @param sourceId 可选，指定源 ID（只清除该源的缓存）
+     */
+    clearCache(sourceId?: string): void;
+    /**
+     * 获取缓存大小
+     */
+    getCacheSize(): number;
+    /**
+     * 睡眠
+     * @param ms 毫秒数
+     */
+    private sleep;
+}
 
 /**
- * 日志等级枚举
+ * Retry Strategy 实现
+ * @description 提供重试延迟计算和错误判断逻辑
  */
-declare enum LogLevel {
-    /** 调试级别：输出最详尽的信息 */
-    DEBUG = 0,
-    /** 信息级别：输出重要的运行状态 */
-    INFO = 1,
-    /** 警告级别：输出潜在的问题，但不影响运行 */
-    WARN = 2,
-    /** 错误级别：输出严重的运行异常 */
-    ERROR = 3,
-    /** 禁用日志：不输出任何信息 */
-    NONE = 4
-}
+
 /**
- * 日志工具类
- * @description 核心工具类，提供统一的日志输出格式 `[Prefix] Message`。
- * 支持通过 `LogLevel` 进行全局过滤。
- * 支持日志缓冲和自动分组，以减少控制台噪音。
- * 支持浏览器端 CSS 样式和 Node.js 端 ANSI 颜色。
+ * 重试策略类
+ * @description 计算重试延迟、判断错误是否可重试
  */
-declare class Logger {
-    /** 全局静态日志等级，所有实例共享 */
-    private static level;
-    /** 日志缓冲区 */
-    private static buffer;
-    /** 缓冲输出防抖定时器 */
-    private static flushTimer;
-    /** 缓冲时间窗口 (ms) */
-    private static FLUSH_INTERVAL;
-    /** 是否启用缓冲模式 */
-    private static bufferEnabled;
-    /** 是否为浏览器环境 */
-    private static isBrowser;
-    /** 当前实例的业务模块前缀 */
-    private prefix;
-    /** 实例特定的颜色 */
-    private color;
+declare class RetryStrategy {
+    private defaultOptions;
     /**
-     * 构造函数
-     * @param prefix - 业务模块前缀，默认为 'App'
+     * 创建重试策略
+     * @param options 重试配置选项
      */
-    constructor(prefix?: string);
+    constructor(options?: RetryOptions);
     /**
-     * 静态方法：设置全局日志输出等级
-     * @param level - 目标日志等级
+     * 计算重试延迟（指数退避）
+     * @param attempt 当前尝试次数 (从 1 开始)
+     * @returns 延迟毫秒数
      */
-    static setLevel(level: LogLevel): void;
+    calculateDelay(attempt: number): number;
     /**
-     * 静态方法：启用或禁用日志缓冲
-     * @param enabled - 是否启用
+     * 判断错误是否可重试
+     * @param error 错误对象
+     * @returns 是否可重试
      */
-    static setBufferEnabled(enabled: boolean): void;
+    isRetryable(error: any): boolean;
     /**
-     * 静态方法：获取当前全局日志等级
-     * @returns 当前生效的全局日志等级
+     * 默认重试条件判断
+     * @param error 错误对象
+     * @returns 是否可重试
      */
-    static getLevel(): LogLevel;
+    private defaultRetryCondition;
     /**
-     * 格式化输出前缀
+     * 获取最大重试次数
      */
-    private getFormattedPrefix;
+    getMaxRetries(): number;
     /**
-     * 生成分组标题参数
+     * 获取基础重试延迟
      */
-    private static getGroupTitleArgs;
+    getBaseDelay(): number;
+}
+
+/** 插件依赖输入 */
+interface PluginDependencyInput {
+    id: string;
+    dependencies: Dependency[];
+}
+/** 共享依赖检测结果 */
+interface SharedDependencyResult {
+    /** 包 ID */
+    packageId: string;
+    /** 请求的版本列表 */
+    requestedVersions: string[];
+    /** 解析后的版本 */
+    resolvedVersion: string;
+    /** 请求者列表 */
+    requestedBy: string[];
+    /** 是否有冲突 */
+    hasConflict: boolean;
+}
+/**
+ * 共享依赖检测器
+ * @description 识别多个插件共享的 npm 包，检查版本冲突，使用最高版本策略解决
+ */
+declare class SharedDepsDetector {
     /**
-     * 内部方法：将日志推入缓冲区或直接输出
+     * 检测共享依赖
+     * @param plugins 插件列表
+     * @returns 共享依赖检测结果
      */
-    private log;
+    detect(plugins: PluginDependencyInput[]): SharedDependencyResult[];
     /**
-     * 静态方法：刷新缓冲区，分组输出日志
+     * 检查版本是否冲突
+     * @param versions 版本列表
+     * @returns 是否有冲突
      */
-    static flush(): void;
+    private checkConflict;
     /**
-     * 打印 DEBUG 级别日志
+     * 最高版本策略
+     * @param versions 版本列表
+     * @returns 最高兼容版本
      */
-    debug(...args: any[]): void;
+    resolveHighest(versions: string[]): string;
     /**
-     * 打印 INFO 级别日志
+     * 最低版本策略
+     * @param versions 版本列表
+     * @returns 最低兼容版本
      */
-    info(...args: any[]): void;
+    resolveLowest(versions: string[]): string;
+}
+
+/** 冲突解决结果 */
+interface ConflictResolution {
+    /** 包 ID */
+    packageId: string;
+    /** 请求的版本列表 */
+    requestedVersions: string[];
+    /** 解析后的版本 */
+    resolvedVersion: string;
+    /** 解决策略 */
+    strategy: 'highest' | 'lowest' | 'user-selected';
+    /** 请求者列表 */
+    requestedBy: string[];
+}
+/**
+ * 版本冲突解决器
+ * @description 使用最高版本策略 (默认) 解决版本冲突
+ */
+declare class ConflictResolver {
     /**
-     * 打印 WARN 级别日志
+     * 解决版本冲突
+     * @param deps 共享依赖检测结果
+     * @param strategy 解决策略，默认 highest
+     * @returns 冲突解决结果
      */
-    warn(...args: any[]): void;
+    resolve(deps: SharedDependencyResult[], strategy?: 'highest' | 'lowest'): ConflictResolution[];
     /**
-     * 打印 ERROR 级别日志
+     * 使用最高版本策略解决
+     * @param dep 共享依赖
+     * @returns 解决的版本
      */
-    error(...args: any[]): void;
+    resolveHighest(dep: SharedDependencyResult): string;
     /**
-     * 开始一个日志控制台分组
+     * 使用最低版本策略解决
+     * @param dep 共享依赖
+     * @returns 解决的版本
      */
-    group(label: string, collapsed?: boolean): void;
+    resolveLowest(dep: SharedDependencyResult): string;
     /**
-     * 结束当前日志控制台分组
+     * 使用 maxSatisfying 解析版本范围
+     * @param range 版本范围
+     * @param versions 可用版本列表
+     * @returns 满足范围的最高版本
      */
-    groupEnd(): void;
+    resolveWithRange(range: string, versions: string[]): string | null;
 }
-/** 默认 Logger 实例 */
-declare const logger: Logger;
+
 /**
- * 创建带特定前缀的 Logger 实例
- * @param prefix 日志前缀
- * @returns Logger 实例
+ * 循环依赖检测
+ * @description 使用 DFS 检测插件依赖中的循环引用，生成警告日志
  */
-declare const createLogger: (prefix: string) => Logger;
 
-type KeepStrategy = 'first' | 'last' | 'search' | 'hash';
+/** 插件依赖输入 */
+interface CycleDetectorInput {
+    id: string;
+    dependencies: Dependency[];
+}
+/** 循环警告 */
+interface CycleWarning {
+    /** 循环路径 */
+    cycle: string[];
+    /** 完整路径 */
+    path: string[];
+}
 /**
- * 把当前地址中所有出现的参数合并成一份。
- * 重复 key 的处理策略：
- *  - 'first'  : 按出现顺序，第一次的值生效
- *  - 'last'   : 按出现顺序，最后一次的值生效（默认，最直观）
- *  - 'search' : 只要 search 里出现过，就用 search 的
- *  - 'hash'   : 只要 hash 里出现过，就用 hash 的
+ * 循环依赖检测器
+ * @description 使用 DFS 检测循环依赖，生成警告但不阻断加载
  */
-declare function normalizeParams(strategy?: KeepStrategy): URLSearchParams;
+declare class CycleDetector {
+    /**
+     * 检测循环依赖
+     * @param plugins 插件列表
+     * @returns 循环警告列表
+     */
+    detect(plugins: CycleDetectorInput[]): CycleWarning[];
+    /**
+     * 从依赖图检测循环
+     * @param graph 依赖图
+     * @returns 循环警告列表
+     */
+    detectFromGraph(graph: Map<string, string[]>): CycleWarning[];
+    /**
+     * 生成循环警告消息
+     * @param warning 循环警告
+     * @returns 警告消息
+     */
+    formatWarning(warning: CycleWarning): string;
+    /**
+     * 格式化所有警告
+     * @param warnings 循环警告列表
+     * @returns 警告消息列表
+     */
+    formatWarnings(warnings: CycleWarning[]): string[];
+}
+
 /**
- * 清除 URL 中的特定参数并返回新的 URL
- * @description 同时处理 search 和 hash 中的参数
+ * 依赖图构建器
+ * @description 提供插件依赖拓扑构建、依赖查询功能
  */
-declare function cleanUrlParams(keysToRemove: string[]): string;
-
-declare const version = "1.0.0";
-
-/** 插件加载 Hook 的配置选项 */
-interface PluginLoaderOptions {
-    /** 插件发现规则，定义如何从模块列表中识别插件 */
-    discoveryRules?: any[];
-    /** 插件模块映射，通常由 Vite 的 `import.meta.glob` 生成，键为路径，值为加载函数 */
-    modules?: Record<string, () => Promise<any>>;
-    /** 预注册的插件注册表，用于手动指定插件加载逻辑，优先级高于自动发现 */
-    registry?: Record<string, () => Promise<any>>;
-    /** 插件的业务配置映射，键为插件 ID */
-    pluginConfigs: Record<string, any>;
-    /** 初始化的共享上下文服务，将注入到每个插件的 onLoad 中 */
-    sharedContext?: Record<string, any>;
-    /** 系统级全局配置，如标题、版本号、Logo 等 */
-    systemConfig?: Record<string, any>;
-    /** 资源发现的基础 URL，默认为当前 window.location.origin */
-    baseUrl?: string;
-}
-/**
- * 核心 Hook：通用插件加载器
- * @description 负责应用启动时的插件全生命周期管理：
- * 1. 自动发现：解析 modules 并根据规则识别插件。
- * 2. 注册：将插件信息录入 PluginManager。
- * 3. 加载：调用插件的加载逻辑 (onLoad)。
- * 4. 初始化：调用插件的挂载逻辑 (onMount)。
- * 5. 响应式更新：订阅插件状态变更并触发 UI 刷新。
- *
- * @param options - 加载配置项
- * @returns { pluginsLoaded: boolean, pluginVersion: number }
- * - pluginsLoaded: 插件是否已全部完成初始化
- * - pluginVersion: 插件状态版本号，用于强制触发依赖插件状态的组件重渲染
+/** 依赖节点 */
+interface DependencyNode {
+    /** 节点 ID (插件或包名) */
+    id: string;
+    /** 直接依赖列表 */
+    dependencies: string[];
+    /** 版本 */
+    version: string;
+}
+/** 依赖边 */
+interface DependencyEdge {
+    from: string;
+    to: string;
+}
+/**
+ * 依赖图
+ * @description 构建和管理插件依赖拓扑
  */
-declare const usePluginLoader: (options: PluginLoaderOptions) => {
-    pluginsLoaded: boolean;
-    pluginVersion: number;
-};
+declare class DependencyGraph {
+    private nodes;
+    private edges;
+    /**
+     * 添加依赖节点
+     * @param node 依赖节点
+     */
+    addNode(node: DependencyNode): void;
+    /**
+     * 添加依赖边
+     * @param from 依赖者 ID
+     * @param to 被依赖者 ID
+     */
+    addEdge(from: string, to: string): void;
+    /**
+     * 获取依赖指定包的所有插件
+     * @param packageId 包 ID
+     * @returns 依赖该包的插件列表
+     */
+    getDependents(packageId: string): string[];
+    /**
+     * 获取指定插件的所有依赖
+     * @param pluginId 插件 ID
+     * @returns 依赖列表
+     */
+    getDependencies(pluginId: string): string[];
+    /**
+     * 获取完整依赖图
+     * @returns 节点 ID 到依赖列表的映射
+     */
+    getGraph(): Map<string, string[]>;
+    /**
+     * 获取所有节点
+     * @returns 节点列表
+     */
+    getNodes(): DependencyNode[];
+    /**
+     * 获取所有边
+     * @returns 边列表
+     */
+    getEdges(): DependencyEdge[];
+    /**
+     * 检查节点是否存在
+     * @param id 节点 ID
+     * @returns 是否存在
+     */
+    hasNode(id: string): boolean;
+    /**
+     * 获取节点
+     * @param id 节点 ID
+     * @returns 节点，不存在返回 undefined
+     */
+    getNode(id: string): DependencyNode | undefined;
+    /**
+     * 清空图
+     */
+    clear(): void;
+    /**
+     * 获取图的大小
+     * @returns 节点数量
+     */
+    size(): number;
+}
 
+/** npm 包元数据 */
+interface NpmPackageMeta {
+    name: string;
+    versions: Record<string, unknown>;
+    'dist-tags': Record<string, string>;
+    time?: Record<string, string>;
+}
+/** 版本信息 */
+interface VersionInfo {
+    version: string;
+    date?: string;
+    deprecated?: boolean;
+}
 /**
- * Hook 配置选项
+ * NPM Registry 客户端
+ * @description 集成 npm Registry API，支持包元数据查询、版本解析和缓存
  */
-interface UseStorageStateOptions<T> {
-    defaultValue?: T;
-    scope?: 'plugin' | 'shared';
+declare class NpmRegistry {
+    private client;
+    private cache;
+    /**
+     * 创建 NPM Registry 客户端
+     * @param baseUrl Registry 基础 URL，默认 https://registry.npmjs.org
+     */
+    constructor(baseUrl?: string);
+    /**
+     * 获取包元数据
+     * @param packageName 包名
+     * @param useCache 是否使用缓存，默认 true
+     * @returns 包元数据，不存在返回 null
+     */
+    getPackageMeta(packageName: string, useCache?: boolean): Promise<NpmPackageMeta | null>;
+    /**
+     * 获取包的所有版本
+     * @param packageName 包名
+     * @returns 版本列表
+     */
+    getVersions(packageName: string): Promise<string[]>;
+    /**
+     * 获取包的最新版本
+     * @param packageName 包名
+     * @returns 最新版本，不存在返回 null
+     */
+    getLatestVersion(packageName: string): Promise<string | null>;
+    /**
+     * 从版本范围解析最佳版本
+     * @param packageName 包名
+     * @param range 版本范围 (如 ^1.0.0, >=1.0.0)
+     * @returns 满足范围的最高版本，不存在返回 null
+     */
+    resolveVersion(packageName: string, range: string): Promise<string | null>;
+    /**
+     * 获取指定版本的详细信息
+     * @param packageName 包名
+     * @param version 版本号
+     * @returns 版本信息，不存在返回 null
+     */
+    getVersionInfo(packageName: string, version: string): Promise<VersionInfo | null>;
+    /**
+     * 批量解析依赖
+     * @param dependencies 依赖列表 [{ id, version }]
+     * @returns 包名到解析后版本的映射
+     */
+    resolveDependencies(dependencies: Array<{
+        id: string;
+        version: string;
+    }>): Promise<Map<string, string>>;
+    /**
+     * 清除缓存
+     * @param packageName 包名，不提供则清除所有缓存
+     */
+    clearCache(packageName?: string): void;
 }
 /**
- * 统一存储状态 Hook
- * @description 提供与 StorageManager 和 Schema Registry 集成的持久化状态 Hook。
- * @param pluginId 定义该 Key 的插件 ID
- * @param key 存储键名 (必须在 Schema 中注册)
- * @param options 配置项，包含默认值和作用域
+ * 获取默认 Registry 实例
+ * @returns 默认 NpmRegistry 实例
  */
-declare function useStorageState<T>(pluginId: string, key: string, options?: UseStorageStateOptions<T>): [T, (value: T | ((val: T) => T)) => void];
+declare function getDefaultRegistry(): NpmRegistry;
 
-export { type ApiAdapter, type ApiConfig, type ApiEndpointConfig, ApiEngine, type ApiInterceptor, ApiProvider, type ApiProviderProps, type ApiRequestConfig, type ApiResponseContext, AvatarSkeleton, AxiosAdapter, BasePlugin, type BaseResponse, BlockSkeleton, ConfigManager, DefaultEventBus, type DiscoveryRule, type ErrorStrategy, type EventBus, type EventBusPort, type EventCallback, type HttpMethod, LocalStorageAdapter, LogLevel, Logger, PLUGIN_TYPES, type Plugin, type PluginCapabilities, type PluginConfigItem, type PluginContext, PluginErrorBoundary, type PluginExtension, type PluginLifecycle, type PluginLoaderOptions, PluginManager, type PluginMetadata, PluginProvider, type PluginProviderProps, type PluginRegistry, PluginRuntime, PluginSandbox, PluginSlot, type PluginStorage, type PluginType, ProxySandbox, type RequestOptions, type RouteConfig, SUCCESS_CODE, type Scene, ScopedStorageAdapter, ServiceRegistry, SidebarIconSkeleton, Slot, type SlotPosition, SlotSkeletons, type SlotType, StatusBarItemSkeleton, type StorageItemSchema, StorageManager, type StoragePort, type StreamCallbacks, type TypedStorage, type UseStorageStateOptions, apiEngine, cleanUrlParams, configManager, createLogger, dateUtils, definePlugin, isMockMode, logger, normalizeParams, pluginManager, resolveApiModules, resolvePluginRegistry, serviceRegistry, useApi, usePluginLoader, usePluginManager, useStorageState, version };
+export { type AIChunk, type AIMessage, type AIProvider, type AITool, type ApiAdapter, type ApiConfig, type ApiEndpointConfig, ApiEngine, type ApiInterceptor, type ApiPort, type ApiRequestConfig, type ApiResponseContext, AxiosAdapter, BasePlugin, type BaseResponse, type CacheEntry, type CacheOptions, type ChatOptions, type Command, type CommandHandler, type CommandType, type Compatibility, ConfigEvents, type ConfigItemDefinition, ConfigManager, type ConflictResolution, ConflictResolver, CoreError, CoreErrorCode, CoreErrorStrategy, type CoreState, CycleDetector, type CycleDetectorInput, type CycleWarning, DEFAULT_PERFORMANCE_SETTINGS, type DeepReadonly, DefaultEventBus, type Dependency, type DependencyEdge, DependencyGraph, type DependencyNode, type DeprecationInfo, type DeprecationWarning, type DiscoveryRule, EXTENSION_TYPES, type Entry, type ErrorHandlerOptions, type ErrorStrategy, type EventBus, type EventBusPort, type EventCallback, type Extension, type ExtensionType, FEATURE_NAMESPACE_PREFIX, type FeatureConfig, type RuleContext as FeatureContext, type FeatureRegistryState, type FeatureRule, type FunctionCallResult, type HookType, type HttpMethod, type LifecycleMetric, LifecycleMonitor, type LifecyclePhase, type LoadError, type LoadResult, LocalStorageAdapter, LogLevel, Logger, type MigrationWarning, MockAIProvider, type NpmPackageMeta, NpmRegistry, type OnActivateHandler, type OnDeactivateHandler, type OnErrorHandler, OpenAIProvider, PLUGIN_TYPES, PerformanceCollector, type PerformanceData, type PerformanceSettings, PerformanceStorage, PerformanceTimer, type Permission, type PermissionAction, type PermissionScope, type PermissionType, type Plugin, type PluginCapabilities, type PluginConfigItem, type PluginContext, type PluginDependencyInput, PluginError, PluginErrorType, PluginEvents, type PluginExtension, type PluginId, PluginIdSchema, type PluginLifecycle, PluginManager, type PluginManifest, PluginManifestSchema, type PluginManifestType, type PluginMetadata, type PluginRegistry, PluginRuntime, PluginSandbox, type PluginStorage, type PluginType, ProxySandbox, RENDER_MODES, RemoteCache, RemoteLoader, type RemotePluginSource, type RemoteSourceOptions, type RenderMode, type RequestOptions, type RetryOptions, RetryStrategy, type RouteConfig, type RoutePath, RoutePathSchema, type RuleContext, type RuleType, type RuntimeMetric, STORAGE_KEY, SUCCESS_CODE, type SafePluginConfig, type SandboxOptions, type Scene, ScopedStorageAdapter, type SemVer, SemVerSchema, ServiceRegistry, type Session, SessionLocalStorageAdapter, SessionManager, type SessionManagerInterface, type SessionStorage, type SharedDependencyResult, SharedDepsDetector, Slot, type SlotKey, SlotKeySchema, type SlotPosition, type SlotType, type StorageItemSchema, StorageManager, type StoragePort, type StreamCallbacks, type ToolCall, ToolRegistry, type TypedStorage, type UseFeatureResult, type ValidationResult, type VersionInfo, apiEngine, assertManifest, cleanUrlParams, configManager, coreStore, coreStoreApi, createAIStore, createEnvironmentRule, createLifecycleMonitor, createLogger, createPercentageRule, createPerformanceMonitor, createPluginId, createRoutePath, createSemVer, createSlotKey, createUserRule, dateUtils, definePlugin, evaluateRules as evaluateFeatureRules, evaluateRule, evaluateRules$1 as evaluateRules, extractManifestFromPlugin, getDefaultRegistry, handleError, simpleHash as hashString, isMockMode, isPluginId, isPluginManifest, isRoutePath, isSemVer, isSlotKey, logger, normalizeParams, normalizePluginManifest, pluginManager, resolveApiModules, resolvePluginRegistry, serviceRegistry, simpleHash$1 as simpleHash, useAIStore, useFeature, useFeatureFlags, validateManifest, version };