@timmy_hu/plugin-middleware 1.0.0 → 1.0.1

package/src/middlewares/plugin-middleware.middleware.ts

@@ -7,9 +7,9 @@ const MIDDLEWARE_PROVIDER = "PluginMiddleware";
 
 /**
  * PluginMiddleware - 插件中间件管理器
- * 
+ *
  * 自动发现所有中间件类型插件，支持动态按需加载、卸载和状态查询。
- * 为智能体编排提供灵活的中间件管理能力。
+ * 通过 /api/auth/login 登录获取 token 后调用平台 API。
  */
 @Injectable()
 @AgentMiddlewareStrategy(MIDDLEWARE_PROVIDER)
@@ -21,467 +21,279 @@ export class PluginMiddleware {
       zh_Hans: "插件中间件管理器"
     },
     description: {
-      en_US: "Discovers all middleware-type plugins and provides dynamic on-demand loading, unloading, and status query tools for agent orchestration.",
-      zh_Hans: "自动发现所有中间件类型插件，支持动态按需加载、卸载和状态查询，为智能体编排提供灵活的中间件管理能力。"
+      en_US: "Discovers all middleware-type plugins and provides dynamic on-demand loading, unloading, and status query tools. Authenticates via /api/auth/login.",
+      zh_Hans: "自动发现所有中间件类型插件，支持动态按需加载、卸载和状态查询。通过 /api/auth/login 登录获取 token 后调用平台 API。"
     },
     configSchema: {
       type: "object",
       properties: {
         platformUrl: {
           type: "string",
-          title: {
-            en_US: "Platform URL",
-            zh_Hans: "平台地址"
-          },
-          description: "XpertAI platform base URL for plugin discovery API",
+          title: { en_US: "Platform URL", zh_Hans: "平台地址" },
+          description: "XpertAI platform base URL",
           default: "http://10.161.48.53:3300"
         },
+        email: {
+          type: "string",
+          title: { en_US: "Email", zh_Hans: "登录邮箱" },
+          description: "Email address for platform login via /api/auth/login"
+        },
+        password: {
+          type: "string",
+          title: { en_US: "Password", zh_Hans: "登录密码" },
+          description: "Password for platform login via /api/auth/login"
+        },
         organizationId: {
           type: "string",
-          title: {
-            en_US: "Organization ID",
-            zh_Hans: "组织 ID"
-          },
+          title: { en_US: "Organization ID", zh_Hans: "组织 ID" },
           description: "Organization ID for scoped plugin queries"
         },
         autoDiscover: {
           type: "boolean",
-          title: {
-            en_US: "Auto Discover",
-            zh_Hans: "自动发现"
-          },
+          title: { en_US: "Auto Discover", zh_Hans: "自动发现" },
           description: "Whether to automatically discover available middleware plugins on startup",
           default: true
         },
         cacheTtlSeconds: {
           type: "number",
-          title: {
-            en_US: "Cache TTL (seconds)",
-            zh_Hans: "缓存有效期（秒）"
-          },
+          title: { en_US: "Cache TTL (seconds)", zh_Hans: "缓存有效期（秒）" },
           description: "How long to cache the discovered plugin list before refreshing",
           default: 300
         }
       },
-      required: ["platformUrl"]
+      required: ["platformUrl", "email", "password"]
     }
   };
 
   createMiddleware(options: any = {}, context: any = {}) {
     const platformUrl = options.platformUrl || "http://10.161.48.53:3300";
+    const email = options.email || "";
+    const password = options.password || "";
     const organizationId = options.organizationId || "";
-    const autoDiscover = options.autoDiscover !== false;
     const cacheTtlSeconds = options.cacheTtlSeconds || 300;
 
-    // In-memory registry for discovered middleware plugins
     const registry = {
       plugins: new Map(),
       loadedPlugins: new Map(),
       lastRefresh: null as number | null,
-      cacheTtl: cacheTtlSeconds * 1000
+      cacheTtl: cacheTtlSeconds * 1000,
+      token: null as string | null,
+      tokenExpiry: null as number | null
     };
 
-    // Helper: fetch middleware plugins from platform API
+    // ---- Login: call /api/auth/login to get token ----
+    async function loginAndGetToken(): Promise<string> {
+      const now = Date.now();
+      if (registry.token && registry.tokenExpiry && now < registry.tokenExpiry) {
+        return registry.token;
+      }
+      if (!email || !password) {
+        throw new Error("缺少登录凭据：请在插件配置中填写 email 和 password");
+      }
+      const fetch = (await import("node-fetch")).default;
+      const resp = await fetch(`${platformUrl}/api/auth/login`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email, password }),
+        timeout: 15000
+      });
+      if (!resp.ok) {
+        const errText = await resp.text();
+        throw new Error(`登录失败 (${resp.status}): ${errText}`);
+      }
+      const data = await resp.json();
+      const token = data.access_token || data.token || (data.data && data.data.access_token);
+      if (!token) {
+        throw new Error(`登录响应中未找到 token 字段，响应: ${JSON.stringify(data)}`);
+      }
+      registry.token = token;
+      registry.tokenExpiry = now + 50 * 60 * 1000; // 50 min
+      return token;
+    }
+
+    function authHeaders(token: string): Record<string, string> {
+      const headers: Record<string, string> = {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      };
+      if (organizationId) headers["organization-id"] = organizationId;
+      return headers;
+    }
+
     async function fetchMiddlewarePlugins() {
       const now = Date.now();
       if (registry.lastRefresh && (now - registry.lastRefresh) < registry.cacheTtl) {
         return Array.from(registry.plugins.values());
       }
-
-      try {
-        const fetch = (await import("node-fetch")).default;
-        const url = `${platformUrl}/api/plugin?category=middleware&organization-id=${encodeURIComponent(organizationId)}`;
-        const resp = await fetch(url, {
-          method: "GET",
-          headers: {
-            "Content-Type": "application/json",
-            ...(organizationId ? { "organization-id": organizationId } : {})
-          },
-          timeout: 10000
-        });
-
-        if (!resp.ok) {
-          throw new Error(`Platform API returned ${resp.status}: ${resp.statusText}`);
-        }
-
-        const data = await resp.json();
-        const pluginList = Array.isArray(data) ? data : (data.data || data.items || data.plugins || []);
-
-        registry.plugins.clear();
-        for (const p of pluginList) {
-          const code = p.code || p.name || p.pluginName;
-          if (code) {
-            registry.plugins.set(code, {
-              code,
-              name: p.name || p.displayName || code,
-              version: p.version || "unknown",
-              description: p.description || "",
-              status: p.status || "available",
-              category: p.category || "middleware",
-              loaded: registry.loadedPlugins.has(code)
-            });
-          }
+      const token = await loginAndGetToken();
+      const fetch = (await import("node-fetch")).default;
+      const url = `${platformUrl}/api/plugin?category=middleware`;
+      const resp = await fetch(url, { method: "GET", headers: authHeaders(token), timeout: 10000 });
+      if (!resp.ok) {
+        if (resp.status === 401) {
+          registry.token = null; registry.tokenExpiry = null;
+          const newToken = await loginAndGetToken();
+          const retryResp = await fetch(url, { method: "GET", headers: authHeaders(newToken), timeout: 10000 });
+          if (!retryResp.ok) throw new Error(`Platform API returned ${retryResp.status}`);
+          return parsePluginList(await retryResp.json());
         }
+        throw new Error(`Platform API returned ${resp.status}: ${resp.statusText}`);
+      }
+      return parsePluginList(await resp.json());
+    }
 
-        registry.lastRefresh = now;
-        return Array.from(registry.plugins.values());
-      } catch (err: any) {
-        if (registry.plugins.size > 0) {
-          return Array.from(registry.plugins.values());
+    function parsePluginList(data: any) {
+      const pluginList = Array.isArray(data) ? data : (data.data || data.items || data.plugins || []);
+      registry.plugins.clear();
+      for (const p of pluginList) {
+        const code = p.code || p.name || p.pluginName;
+        if (code) {
+          registry.plugins.set(code, {
+            code, name: p.name || p.displayName || code,
+            version: p.version || "unknown", description: p.description || "",
+            status: p.status || "available", category: p.category || "middleware",
+            loaded: registry.loadedPlugins.has(code)
+          });
         }
-        throw new Error(`Failed to discover middleware plugins: ${err.message}`);
       }
+      registry.lastRefresh = Date.now();
+      return Array.from(registry.plugins.values());
     }
 
-    // Tool 1: List all discovered middleware plugins
+    // Tool 1: list_middleware_plugins
     const listMiddlewarePlugins = tool(
       async (input) => {
         try {
           const plugins = await fetchMiddlewarePlugins();
           const filter = input.filter || "all";
-
           let filtered = plugins;
-          if (filter === "loaded") {
-            filtered = plugins.filter((p: any) => p.loaded || registry.loadedPlugins.has(p.code));
-          } else if (filter === "available") {
-            filtered = plugins.filter((p: any) => !p.loaded && !registry.loadedPlugins.has(p.code));
-          }
-
+          if (filter === "loaded") filtered = plugins.filter((p: any) => p.loaded || registry.loadedPlugins.has(p.code));
+          else if (filter === "available") filtered = plugins.filter((p: any) => !p.loaded && !registry.loadedPlugins.has(p.code));
           return {
-            success: true,
-            total: filtered.length,
+            success: true, total: filtered.length,
             plugins: filtered.map((p: any) => ({
-              code: p.code,
-              name: p.name,
-              version: p.version,
-              description: p.description,
+              code: p.code, name: p.name, version: p.version, description: p.description,
               status: registry.loadedPlugins.has(p.code) ? "loaded" : "available",
-              loadedAt: registry.loadedPlugins.has(p.code)
-                ? registry.loadedPlugins.get(p.code).loadedAt
-                : null
+              loadedAt: registry.loadedPlugins.has(p.code) ? registry.loadedPlugins.get(p.code).loadedAt : null
             }))
           };
-        } catch (err: any) {
-          return {
-            success: false,
-            error: err.message,
-            plugins: []
-          };
-        }
+        } catch (err: any) { return { success: false, error: err.message, plugins: [] }; }
       },
-      {
-        name: "list_middleware_plugins",
-        description: "列出所有已发现的中间件类型插件，可按加载状态过滤。返回插件编码、名称、版本、描述和当前状态。",
-        schema: z.object({
-          filter: z.enum(["all", "loaded", "available"]).optional().default("all")
-            .describe("过滤条件：all=全部, loaded=已加载, available=可用未加载")
-        })
-      }
+      { name: "list_middleware_plugins", description: "列出所有已发现的中间件类型插件，可按加载状态过滤。", schema: z.object({ filter: z.enum(["all", "loaded", "available"]).optional().default("all").describe("过滤条件") }) }
     );
 
-    // Tool 2: Load a specific middleware plugin by code
+    // Tool 2: load_middleware_plugin
     const loadMiddlewarePlugin = tool(
       async (input) => {
         const pluginCode = input.pluginCode;
-
-        if (registry.loadedPlugins.has(pluginCode)) {
-          return {
-            success: true,
-            message: `插件 ${pluginCode} 已经处于加载状态`,
-            plugin: {
-              code: pluginCode,
-              loadedAt: registry.loadedPlugins.get(pluginCode).loadedAt,
-              status: "already_loaded"
-            }
-          };
-        }
-
+        if (registry.loadedPlugins.has(pluginCode)) return { success: true, message: `插件 ${pluginCode} 已经处于加载状态`, plugin: { code: pluginCode, loadedAt: registry.loadedPlugins.get(pluginCode).loadedAt, status: "already_loaded" } };
         const plugins = await fetchMiddlewarePlugins();
         const target = plugins.find((p: any) => p.code === pluginCode);
-
-        if (!target) {
-          return {
-            success: false,
-            error: `未找到编码为 ${pluginCode} 的中间件插件`,
-            availablePlugins: plugins.map((p: any) => p.code)
-          };
-        }
-
+        if (!target) return { success: false, error: `未找到编码为 ${pluginCode} 的中间件插件`, availablePlugins: plugins.map((p: any) => p.code) };
         try {
+          const token = await loginAndGetToken();
           const fetch = (await import("node-fetch")).default;
-          const loadUrl = `${platformUrl}/api/plugin/load`;
-          const resp = await fetch(loadUrl, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              ...(organizationId ? { "organization-id": organizationId } : {})
-            },
-            body: JSON.stringify({
-              pluginName: target.name || pluginCode,
-              version: target.version,
-              source: "npm"
-            }),
-            timeout: 30000
-          });
-
-          if (!resp.ok) {
-            const errText = await resp.text();
-            throw new Error(`Load API returned ${resp.status}: ${errText}`);
-          }
-
+          const resp = await fetch(`${platformUrl}/api/plugin/load`, { method: "POST", headers: authHeaders(token), body: JSON.stringify({ pluginName: target.name || pluginCode, version: target.version, source: "npm" }), timeout: 30000 });
+          if (!resp.ok) throw new Error(`Load API returned ${resp.status}: ${await resp.text()}`);
           const result = await resp.json();
-
-          registry.loadedPlugins.set(pluginCode, {
-            code: pluginCode,
-            name: target.name,
-            version: target.version,
-            loadedAt: new Date().toISOString(),
-            loadResult: result
-          });
-
-          return {
-            success: true,
-            message: `插件 ${pluginCode} 加载成功`,
-            plugin: {
-              code: pluginCode,
-              name: target.name,
-              version: target.version,
-              loadedAt: registry.loadedPlugins.get(pluginCode).loadedAt,
-              status: "loaded"
-            }
-          };
+          registry.loadedPlugins.set(pluginCode, { code: pluginCode, name: target.name, version: target.version, loadedAt: new Date().toISOString(), loadResult: result });
+          return { success: true, message: `插件 ${pluginCode} 加载成功`, plugin: { code: pluginCode, name: target.name, version: target.version, loadedAt: registry.loadedPlugins.get(pluginCode).loadedAt, status: "loaded" } };
         } catch (err: any) {
-          registry.loadedPlugins.set(pluginCode, {
-            code: pluginCode,
-            name: target.name,
-            version: target.version,
-            loadedAt: new Date().toISOString(),
-            loadResult: { offline: true, error: err.message }
-          });
-
-          return {
-            success: true,
-            message: `插件 ${pluginCode} 已标记为加载（离线模式）`,
-            plugin: {
-              code: pluginCode,
-              name: target.name,
-              version: target.version,
-              loadedAt: registry.loadedPlugins.get(pluginCode).loadedAt,
-              status: "loaded_offline",
-              warning: err.message
-            }
-          };
+          registry.loadedPlugins.set(pluginCode, { code: pluginCode, name: target.name, version: target.version, loadedAt: new Date().toISOString(), loadResult: { offline: true, error: err.message } });
+          return { success: true, message: `插件 ${pluginCode} 已标记为加载（离线模式）`, plugin: { code: pluginCode, name: target.name, version: target.version, loadedAt: registry.loadedPlugins.get(pluginCode).loadedAt, status: "loaded_offline", warning: err.message } };
         }
       },
-      {
-        name: "load_middleware_plugin",
-        description: "按插件编码动态加载指定的中间件插件。加载后该插件的工具和能力将对智能体可用。",
-        schema: z.object({
-          pluginCode: z.string().min(1).describe("要加载的中间件插件编码，例如 'weather-query' 或 'pg-query-tool'")
-        })
-      }
+      { name: "load_middleware_plugin", description: "按插件编码动态加载指定的中间件插件。", schema: z.object({ pluginCode: z.string().min(1).describe("要加载的中间件插件编码") }) }
     );
 
-    // Tool 3: Unload a specific middleware plugin
+    // Tool 3: unload_middleware_plugin
     const unloadMiddlewarePlugin = tool(
       async (input) => {
         const pluginCode = input.pluginCode;
-
-        if (!registry.loadedPlugins.has(pluginCode)) {
-          return {
-            success: false,
-            error: `插件 ${pluginCode} 当前未加载，无需卸载`,
-            loadedPlugins: Array.from(registry.loadedPlugins.keys())
-          };
-        }
-
+        if (!registry.loadedPlugins.has(pluginCode)) return { success: false, error: `插件 ${pluginCode} 当前未加载，无需卸载`, loadedPlugins: Array.from(registry.loadedPlugins.keys()) };
         try {
+          const token = await loginAndGetToken();
           const fetch = (await import("node-fetch")).default;
-          const unloadUrl = `${platformUrl}/api/plugin/unload`;
-          const resp = await fetch(unloadUrl, {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-              ...(organizationId ? { "organization-id": organizationId } : {})
-            },
-            body: JSON.stringify({ pluginCode }),
-            timeout: 15000
-          });
-
-          if (!resp.ok) {
-            const errText = await resp.text();
-            throw new Error(`Unload API returned ${resp.status}: ${errText}`);
-          }
-        } catch (err: any) {
-          // Continue with local unload even if API fails
-        }
-
+          const resp = await fetch(`${platformUrl}/api/plugin/unload`, { method: "POST", headers: authHeaders(token), body: JSON.stringify({ pluginCode }), timeout: 15000 });
+          if (!resp.ok) throw new Error(`Unload API returned ${resp.status}: ${await resp.text()}`);
+        } catch (err: any) { /* continue */ }
         const removed = registry.loadedPlugins.get(pluginCode);
         registry.loadedPlugins.delete(pluginCode);
-
-        return {
-          success: true,
-          message: `插件 ${pluginCode} 已卸载`,
-          plugin: {
-            code: pluginCode,
-            name: removed.name,
-            unloadedAt: new Date().toISOString(),
-            status: "unloaded"
-          }
-        };
+        return { success: true, message: `插件 ${pluginCode} 已卸载`, plugin: { code: pluginCode, name: removed.name, unloadedAt: new Date().toISOString(), status: "unloaded" } };
       },
-      {
-        name: "unload_middleware_plugin",
-        description: "按插件编码卸载已加载的中间件插件。卸载后该插件的工具将不再对智能体可用。",
-        schema: z.object({
-          pluginCode: z.string().min(1).describe("要卸载的中间件插件编码")
-        })
-      }
+      { name: "unload_middleware_plugin", description: "按插件编码卸载已加载的中间件插件。", schema: z.object({ pluginCode: z.string().min(1).describe("要卸载的中间件插件编码") }) }
     );
 
-    // Tool 4: Query detailed status of a specific middleware plugin
+    // Tool 4: get_middleware_plugin_status
     const getMiddlewarePluginStatus = tool(
       async (input) => {
         const pluginCode = input.pluginCode;
         const plugins = await fetchMiddlewarePlugins();
         const target = plugins.find((p: any) => p.code === pluginCode);
-
-        if (!target) {
-          return {
-            success: false,
-            error: `未找到编码为 ${pluginCode} 的中间件插件`
-          };
-        }
-
+        if (!target) return { success: false, error: `未找到编码为 ${pluginCode} 的中间件插件` };
         const loaded = registry.loadedPlugins.has(pluginCode);
         const loadInfo = loaded ? registry.loadedPlugins.get(pluginCode) : null;
-
-        return {
-          success: true,
-          plugin: {
-            code: target.code,
-            name: target.name,
-            version: target.version,
-            description: target.description,
-            category: target.category,
-            status: loaded ? "loaded" : "available",
-            loadedAt: loadInfo ? loadInfo.loadedAt : null,
-            tools: loaded ? (loadInfo.tools || []) : [],
-            configRequired: target.configRequired || []
-          }
-        };
+        return { success: true, plugin: { code: target.code, name: target.name, version: target.version, description: target.description, category: target.category, status: loaded ? "loaded" : "available", loadedAt: loadInfo ? loadInfo.loadedAt : null, tools: loaded ? (loadInfo.tools || []) : [], configRequired: target.configRequired || [] } };
       },
-      {
-        name: "get_middleware_plugin_status",
-        description: "查询指定中间件插件的详细状态信息，包括加载状态、版本、描述和可用工具列表。",
-        schema: z.object({
-          pluginCode: z.string().min(1).describe("要查询的中间件插件编码")
-        })
-      }
+      { name: "get_middleware_plugin_status", description: "查询指定中间件插件的详细状态信息。", schema: z.object({ pluginCode: z.string().min(1).describe("要查询的中间件插件编码") }) }
     );
 
-    // Tool 5: Refresh the plugin discovery cache
+    // Tool 5: refresh_plugin_cache
     const refreshPluginCache = tool(
       async (input) => {
-        registry.lastRefresh = null;
+        registry.lastRefresh = null; registry.token = null; registry.tokenExpiry = null;
         try {
           const plugins = await fetchMiddlewarePlugins();
-          return {
-            success: true,
-            message: `缓存已刷新，发现 ${plugins.length} 个中间件插件`,
-            total: plugins.length,
-            refreshedAt: new Date().toISOString()
-          };
-        } catch (err: any) {
-          return {
-            success: false,
-            error: `刷新缓存失败: ${err.message}`
-          };
-        }
+          return { success: true, message: `缓存已刷新，发现 ${plugins.length} 个中间件插件`, total: plugins.length, refreshedAt: new Date().toISOString() };
+        } catch (err: any) { return { success: false, error: `刷新缓存失败: ${err.message}` }; }
       },
-      {
-        name: "refresh_plugin_cache",
-        description: "刷新中间件插件发现缓存，强制从平台重新获取所有中间件类型插件列表。",
-        schema: z.object({})
-      }
+      { name: "refresh_plugin_cache", description: "刷新中间件插件发现缓存，强制重新登录并获取插件列表。", schema: z.object({}) }
     );
 
-    // Tool 6: Batch load multiple middleware plugins
+    // Tool 6: batch_load_middleware_plugins
     const batchLoadMiddlewarePlugins = tool(
       async (input) => {
         const pluginCodes = input.pluginCodes;
-        const results = [];
-
+        const results: any[] = [];
         const plugins = await fetchMiddlewarePlugins();
-
         for (const code of pluginCodes) {
-          if (registry.loadedPlugins.has(code)) {
-            results.push({
-              code,
-              status: "already_loaded",
-              success: true
-            });
-            continue;
-          }
-
+          if (registry.loadedPlugins.has(code)) { results.push({ code, status: "already_loaded", success: true }); continue; }
           const target = plugins.find((p: any) => p.code === code);
-          if (!target) {
-            results.push({
-              code,
-              status: "not_found",
-              success: false,
-              error: `未找到编码为 ${code} 的中间件插件`
-            });
-            continue;
+          if (!target) { results.push({ code, status: "not_found", success: false, error: `未找到编码为 ${code} 的中间件插件` }); continue; }
+          try {
+            const token = await loginAndGetToken();
+            const fetch = (await import("node-fetch")).default;
+            const resp = await fetch(`${platformUrl}/api/plugin/load`, { method: "POST", headers: authHeaders(token), body: JSON.stringify({ pluginName: target.name || code, version: target.version, source: "npm" }), timeout: 30000 });
+            if (!resp.ok) throw new Error(`Load API returned ${resp.status}`);
+            const result = await resp.json();
+            registry.loadedPlugins.set(code, { code, name: target.name, version: target.version, loadedAt: new Date().toISOString(), loadResult: result });
+            results.push({ code, name: target.name, version: target.version, status: "loaded", success: true, loadedAt: registry.loadedPlugins.get(code).loadedAt });
+          } catch (err: any) {
+            registry.loadedPlugins.set(code, { code, name: target.name, version: target.version, loadedAt: new Date().toISOString(), loadResult: { offline: true, error: err.message } });
+            results.push({ code, name: target.name, version: target.version, status: "loaded_offline", success: true, warning: err.message });
           }
-
-          registry.loadedPlugins.set(code, {
-            code,
-            name: target.name,
-            version: target.version,
-            loadedAt: new Date().toISOString(),
-            loadResult: { batch: true }
-          });
-
-          results.push({
-            code,
-            name: target.name,
-            version: target.version,
-            status: "loaded",
-            success: true,
-            loadedAt: registry.loadedPlugins.get(code).loadedAt
-          });
         }
+        return { success: true, total: pluginCodes.length, loaded: results.filter((r: any) => r.status === "loaded").length, alreadyLoaded: results.filter((r: any) => r.status === "already_loaded").length, failed: results.filter((r: any) => !r.success).length, results };
+      },
+      { name: "batch_load_middleware_plugins", description: "批量加载多个中间件插件。", schema: z.object({ pluginCodes: z.array(z.string().min(1)).min(1).describe("要批量加载的中间件插件编码数组") }) }
+    );
 
-        return {
-          success: true,
-          total: pluginCodes.length,
-          loaded: results.filter((r: any) => r.status === "loaded").length,
-          alreadyLoaded: results.filter((r: any) => r.status === "already_loaded").length,
-          failed: results.filter((r: any) => !r.success).length,
-          results
-        };
+    // Tool 7: check_login_status
+    const checkLoginStatus = tool(
+      async (input) => {
+        try {
+          await loginAndGetToken();
+          return { success: true, loggedIn: true, email, platformUrl, tokenExpiry: registry.tokenExpiry ? new Date(registry.tokenExpiry).toISOString() : null, message: "登录状态正常，token 有效" };
+        } catch (err: any) {
+          return { success: false, loggedIn: false, email, platformUrl, error: err.message };
+        }
       },
-      {
-        name: "batch_load_middleware_plugins",
-        description: "批量加载多个中间件插件。传入插件编码数组，一次性加载所有指定的中间件插件。",
-        schema: z.object({
-          pluginCodes: z.array(z.string().min(1)).min(1)
-            .describe("要批量加载的中间件插件编码数组，例如 ['weather-query', 'pg-query-tool']")
-        })
-      }
+      { name: "check_login_status", description: "检查当前平台登录状态，验证 email/password 是否有效、token 是否过期。", schema: z.object({}) }
     );
 
     return {
       name: MIDDLEWARE_PROVIDER,
-      tools: [
-        listMiddlewarePlugins,
-        loadMiddlewarePlugin,
-        unloadMiddlewarePlugin,
-        getMiddlewarePluginStatus,
-        refreshPluginCache,
-        batchLoadMiddlewarePlugins
-      ]
+      tools: [listMiddlewarePlugins, loadMiddlewarePlugin, unloadMiddlewarePlugin, getMiddlewarePluginStatus, refreshPluginCache, batchLoadMiddlewarePlugins, checkLoginStatus]
     };
   }
 }

package/src/schemas/config.schema.ts

@@ -2,14 +2,22 @@ import { z } from "zod";
 
 /**
  * 插件中间件配置 Schema
- * 
- * 定义插件运行所需的所有配置项，包括平台地址、组织 ID、自动发现开关和缓存策略。
+ *
+ * 定义插件运行所需的所有配置项，包括平台地址、登录凭据、组织 ID、自动发现开关和缓存策略。
  */
 export const PluginMiddlewareConfigSchema = z.object({
-  /** XpertAI 平台基础地址，用于调用插件发现和加载 API */
+  /** XpertAI 平台基础地址，用于调用登录和插件 API */
   platformUrl: z.string().url().default("http://10.161.48.53:3300")
     .describe("XpertAI 平台基础地址"),
 
+  /** 登录邮箱，用于调用 /api/auth/login */
+  email: z.string().email()
+    .describe("登录邮箱，用于调用 /api/auth/login 获取 token"),
+
+  /** 登录密码，用于调用 /api/auth/login */
+  password: z.string().min(1)
+    .describe("登录密码，用于调用 /api/auth/login 获取 token"),
+
   /** 组织 ID，用于限定插件查询范围 */
   organizationId: z.string().optional()
     .describe("组织 ID，用于限定插件查询范围"),