@timmy_hu/plugin-middleware 1.0.0

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

@@ -0,0 +1,487 @@
+import { Injectable } from "@nestjs/common";
+import { AgentMiddlewareStrategy } from "@xpert-ai/plugin-sdk";
+import { tool } from "@langchain/core/tools";
+import { z } from "zod";
+
+const MIDDLEWARE_PROVIDER = "PluginMiddleware";
+
+/**
+ * PluginMiddleware - 插件中间件管理器
+ * 
+ * 自动发现所有中间件类型插件，支持动态按需加载、卸载和状态查询。
+ * 为智能体编排提供灵活的中间件管理能力。
+ */
+@Injectable()
+@AgentMiddlewareStrategy(MIDDLEWARE_PROVIDER)
+export class PluginMiddleware {
+  public readonly meta = {
+    name: MIDDLEWARE_PROVIDER,
+    label: {
+      en_US: "Plugin Middleware Manager",
+      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: "自动发现所有中间件类型插件，支持动态按需加载、卸载和状态查询，为智能体编排提供灵活的中间件管理能力。"
+    },
+    configSchema: {
+      type: "object",
+      properties: {
+        platformUrl: {
+          type: "string",
+          title: {
+            en_US: "Platform URL",
+            zh_Hans: "平台地址"
+          },
+          description: "XpertAI platform base URL for plugin discovery API",
+          default: "http://10.161.48.53:3300"
+        },
+        organizationId: {
+          type: "string",
+          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: "自动发现"
+          },
+          description: "Whether to automatically discover available middleware plugins on startup",
+          default: true
+        },
+        cacheTtlSeconds: {
+          type: "number",
+          title: {
+            en_US: "Cache TTL (seconds)",
+            zh_Hans: "缓存有效期（秒）"
+          },
+          description: "How long to cache the discovered plugin list before refreshing",
+          default: 300
+        }
+      },
+      required: ["platformUrl"]
+    }
+  };
+
+  createMiddleware(options: any = {}, context: any = {}) {
+    const platformUrl = options.platformUrl || "http://10.161.48.53:3300";
+    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
+    };
+
+    // Helper: fetch middleware plugins from platform API
+    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)
+            });
+          }
+        }
+
+        registry.lastRefresh = now;
+        return Array.from(registry.plugins.values());
+      } catch (err: any) {
+        if (registry.plugins.size > 0) {
+          return Array.from(registry.plugins.values());
+        }
+        throw new Error(`Failed to discover middleware plugins: ${err.message}`);
+      }
+    }
+
+    // Tool 1: List all discovered 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));
+          }
+
+          return {
+            success: true,
+            total: filtered.length,
+            plugins: filtered.map((p: any) => ({
+              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
+            }))
+          };
+        } 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=可用未加载")
+        })
+      }
+    );
+
+    // Tool 2: Load a specific middleware plugin by code
+    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"
+            }
+          };
+        }
+
+        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)
+          };
+        }
+
+        try {
+          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 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"
+            }
+          };
+        } 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
+            }
+          };
+        }
+      },
+      {
+        name: "load_middleware_plugin",
+        description: "按插件编码动态加载指定的中间件插件。加载后该插件的工具和能力将对智能体可用。",
+        schema: z.object({
+          pluginCode: z.string().min(1).describe("要加载的中间件插件编码，例如 'weather-query' 或 'pg-query-tool'")
+        })
+      }
+    );
+
+    // Tool 3: Unload a specific 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())
+          };
+        }
+
+        try {
+          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 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"
+          }
+        };
+      },
+      {
+        name: "unload_middleware_plugin",
+        description: "按插件编码卸载已加载的中间件插件。卸载后该插件的工具将不再对智能体可用。",
+        schema: z.object({
+          pluginCode: z.string().min(1).describe("要卸载的中间件插件编码")
+        })
+      }
+    );
+
+    // Tool 4: Query detailed status of a specific middleware plugin
+    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} 的中间件插件`
+          };
+        }
+
+        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 || []
+          }
+        };
+      },
+      {
+        name: "get_middleware_plugin_status",
+        description: "查询指定中间件插件的详细状态信息，包括加载状态、版本、描述和可用工具列表。",
+        schema: z.object({
+          pluginCode: z.string().min(1).describe("要查询的中间件插件编码")
+        })
+      }
+    );
+
+    // Tool 5: Refresh the plugin discovery cache
+    const refreshPluginCache = tool(
+      async (input) => {
+        registry.lastRefresh = 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}`
+          };
+        }
+      },
+      {
+        name: "refresh_plugin_cache",
+        description: "刷新中间件插件发现缓存，强制从平台重新获取所有中间件类型插件列表。",
+        schema: z.object({})
+      }
+    );
+
+    // Tool 6: Batch load multiple middleware plugins
+    const batchLoadMiddlewarePlugins = tool(
+      async (input) => {
+        const pluginCodes = input.pluginCodes;
+        const results = [];
+
+        const plugins = await fetchMiddlewarePlugins();
+
+        for (const code of pluginCodes) {
+          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;
+          }
+
+          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("要批量加载的中间件插件编码数组，例如 ['weather-query', 'pg-query-tool']")
+        })
+      }
+    );
+
+    return {
+      name: MIDDLEWARE_PROVIDER,
+      tools: [
+        listMiddlewarePlugins,
+        loadMiddlewarePlugin,
+        unloadMiddlewarePlugin,
+        getMiddlewarePluginStatus,
+        refreshPluginCache,
+        batchLoadMiddlewarePlugins
+      ]
+    };
+  }
+}

package/src/plugin-middleware.module.ts

@@ -0,0 +1,15 @@
+import { DynamicModule, Module } from "@nestjs/common";
+import { PluginMiddleware } from "./middlewares/plugin-middleware.middleware";
+
+@Module({})
+export class PluginMiddlewareModule {
+  static register(ctx?: any): DynamicModule {
+    return {
+      module: PluginMiddlewareModule,
+      global: true,
+      providers: [PluginMiddleware],
+      controllers: [],
+      exports: [PluginMiddleware],
+    };
+  }
+}

package/src/schemas/config.schema.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+
+/**
+ * 插件中间件配置 Schema
+ * 
+ * 定义插件运行所需的所有配置项，包括平台地址、组织 ID、自动发现开关和缓存策略。
+ */
+export const PluginMiddlewareConfigSchema = z.object({
+  /** XpertAI 平台基础地址，用于调用插件发现和加载 API */
+  platformUrl: z.string().url().default("http://10.161.48.53:3300")
+    .describe("XpertAI 平台基础地址"),
+
+  /** 组织 ID，用于限定插件查询范围 */
+  organizationId: z.string().optional()
+    .describe("组织 ID，用于限定插件查询范围"),
+
+  /** 是否在启动时自动发现可用的中间件插件 */
+  autoDiscover: z.boolean().default(true)
+    .describe("是否在启动时自动发现可用的中间件插件"),
+
+  /** 插件发现缓存有效期（秒），过期后自动刷新 */
+  cacheTtlSeconds: z.number().int().min(10).max(3600).default(300)
+    .describe("插件发现缓存有效期（秒）"),
+
+  /** 加载超时时间（毫秒） */
+  loadTimeoutMs: z.number().int().min(1000).max(120000).default(30000)
+    .describe("插件加载超时时间（毫秒）"),
+
+  /** 是否启用离线模式（API 不可用时仍可本地管理插件状态） */
+  offlineMode: z.boolean().default(true)
+    .describe("是否启用离线模式")
+});
+
+export type PluginMiddlewareConfig = z.infer<typeof PluginMiddlewareConfigSchema>;