@ai-setting/roy-agent-core 1.5.36 → 1.5.40

package/dist/shared/@ai-setting/{roy-agent-core-xs5rsgat.js → roy-agent-core-58k274fg.js}

@@ -1,7 +1,7 @@
 import {
   SQLiteSpanStorage,
   init_span_storage
-} from "./roy-agent-core-psv4v63c.js";
+} from "./roy-agent-core-c6592r3c.js";
 import {
   __esm,
   __export,
@@ -95,6 +95,9 @@ __export(exports_tracer_provider, {
   getTracerProvider: () => getTracerProvider,
   OTelTracerProvider: () => OTelTracerProvider
 });
+function isOtelTraceDebugEnabled() {
+  return process.env.ROY_TRACE_DEBUG_OTEL === "1" || process.env.ROY_TRACE_DEBUG === "1";
+}
 
 class OTelSpanImpl {
   name;
@@ -129,19 +132,40 @@ class OTelSpanImpl {
     if (error) {
       this.error = error.message;
     }
-    this.storage.save({
-      traceId: this.spanContext.traceId,
-      spanId: this.spanContext.spanId,
-      parentSpanId: this.spanContext.parentSpanId,
-      name: this.name,
-      kind: this.kind,
-      status: error ? "error" /* ERROR */ : "ok" /* OK */,
-      startTime: this.startTime,
-      endTime: this.endTime,
-      attributes: this.attributes,
-      result,
-      error: this.error
-    });
+    const duration = this.endTime - (this.startTime || 0);
+    if (isOtelTraceDebugEnabled()) {
+      console.log(`[OTelSpan] Ending span: name="${this.name}" traceId=${this.spanContext.traceId} spanId=${this.spanContext.spanId} duration=${duration}ms status=${error ? "ERROR" : "OK"}`);
+    }
+    let storage = this.storage;
+    if (!storage) {
+      console.warn(`[OTelSpan] storage is null for "${this.name}", attempting to re-fetch...`);
+      const provider = getTracerProvider();
+      storage = provider.getStorage();
+    }
+    if (storage) {
+      const isInitialized = storage.db || storage.initialized;
+      if (!isInitialized) {
+        console.warn(`[OTelSpan] storage not initialized for "${this.name}", initializing now...`);
+        storage.initialize().catch((err) => {
+          console.error(`[OTelSpan] Failed to initialize storage:`, err);
+        });
+      }
+      storage.save({
+        traceId: this.spanContext.traceId,
+        spanId: this.spanContext.spanId,
+        parentSpanId: this.spanContext.parentSpanId,
+        name: this.name,
+        kind: this.kind,
+        status: error ? "error" /* ERROR */ : "ok" /* OK */,
+        startTime: this.startTime,
+        endTime: this.endTime,
+        attributes: this.attributes,
+        result,
+        error: this.error
+      });
+    } else {
+      console.error(`[OTelSpan] Failed to save span "${this.name}": storage still null after re-fetch`);
+    }
     this.onEnd?.();
   }
 }
@@ -154,11 +178,13 @@ class OTelTracerImpl {
   activeSpans = new Map;
   onSpanEndCallback;
   provider;
+  instanceId;
   constructor(name, version, storage, provider) {
     this.name = name;
     this.version = version;
     this.storage = storage;
     this.provider = provider;
+    this.instanceId = `${name}@${provider.instanceId}`;
   }
   setOnSpanEndCallback(callback) {
     this.onSpanEndCallback = callback;
@@ -169,8 +195,37 @@ class OTelTracerImpl {
   startSpan(name, options) {
     const parentFromOptions = options?.parent;
     const hasExplicitParent = options && "parent" in options;
+    const hasExplicitContext = options && "context" in options;
     const globalContext = this.provider.getGlobalContext();
     let effectiveParentContext;
+    let traceId;
+    let spanId;
+    let parentSpanId;
+    let spanContext;
+    if (hasExplicitContext && options?.context) {
+      const injectedContext = options.context;
+      traceId = injectedContext.traceId;
+      spanId = this.generateSpanId();
+      parentSpanId = injectedContext.spanId;
+      spanContext = {
+        traceId,
+        spanId,
+        parentSpanId
+      };
+      this.currentContext = {
+        traceId,
+        spanId,
+        parentSpanId
+      };
+      const span2 = new OTelSpanImpl(name, spanContext, this.storage, injectedContext, () => this.handleSpanEnd(spanContext.spanId, injectedContext.spanId));
+      if (options?.attributes) {
+        for (const [key, value] of Object.entries(options.attributes)) {
+          span2.setAttribute(key, value);
+        }
+      }
+      this.activeSpans.set(spanId, span2);
+      return span2;
+    }
     if (hasExplicitParent) {
       effectiveParentContext = parentFromOptions;
     } else if (this.currentContext) {
@@ -178,9 +233,8 @@ class OTelTracerImpl {
     } else if (globalContext) {
       effectiveParentContext = globalContext;
     }
-    const traceId = effectiveParentContext?.traceId || this.generateTraceId();
-    const spanId = this.generateSpanId();
-    let parentSpanId;
+    traceId = effectiveParentContext?.traceId || this.generateTraceId();
+    spanId = this.generateSpanId();
     if (hasExplicitParent && parentFromOptions) {
       parentSpanId = parentFromOptions.parentSpanId || parentFromOptions.spanId;
     } else if (this.currentContext) {
@@ -188,7 +242,7 @@ class OTelTracerImpl {
     } else if (globalContext) {
       parentSpanId = globalContext.spanId;
     }
-    const spanContext = {
+    spanContext = {
       traceId,
       spanId,
       parentSpanId
@@ -205,6 +259,9 @@ class OTelTracerImpl {
       }
     }
     this.activeSpans.set(spanId, span);
+    if (isOtelTraceDebugEnabled()) {
+      console.log(`[OTelTracer] ✓ Span created: name="${name}" traceId=${traceId} spanId=${spanId} parentSpanId=${parentSpanId || "-"}`);
+    }
     return span;
   }
   injectToEnv(env) {
@@ -218,6 +275,14 @@ class OTelTracerImpl {
   setCurrentContext(context) {
     this.currentContext = context;
   }
+  findStackParentSpan(spanId) {
+    for (const [, span] of this.activeSpans) {
+      if (span.spanContext.parentSpanId === spanId) {
+        return span;
+      }
+    }
+    return;
+  }
   endSpan(span) {
     const spanContext = span.spanContext;
     this.activeSpans.delete(spanContext.spanId);
@@ -243,6 +308,16 @@ class OTelTracerImpl {
         return parentContext;
       }
     }
+    const stackParentSpan = this.findStackParentSpan(spanContext.spanId);
+    if (stackParentSpan) {
+      const parentContext = {
+        traceId: stackParentSpan.spanContext.traceId,
+        spanId: stackParentSpan.spanContext.spanId,
+        parentSpanId: stackParentSpan.spanContext.parentSpanId
+      };
+      this.currentContext = parentContext;
+      return parentContext;
+    }
     this.currentContext = undefined;
     return;
   }
@@ -255,8 +330,6 @@ class OTelTracerImpl {
     return Math.floor(Math.random() * 18446744073709552000).toString(16).padStart(16, "0");
   }
   handleSpanEnd(spanId, parentSpanId) {
-    this.activeSpans.delete(spanId);
-    const currentTraceId = this.currentContext?.traceId;
     if (parentSpanId) {
       const parentSpan = this.activeSpans.get(parentSpanId);
       if (parentSpan) {
@@ -267,15 +340,24 @@ class OTelTracerImpl {
         };
         return;
       }
-      if (currentTraceId) {
+      if (this.currentContext?.traceId) {
         this.currentContext = {
-          traceId: currentTraceId,
+          traceId: this.currentContext.traceId,
           spanId: parentSpanId,
           parentSpanId: undefined
         };
         return;
       }
     }
+    const stackParentSpan = this.findStackParentSpan(spanId);
+    if (stackParentSpan) {
+      this.currentContext = {
+        traceId: stackParentSpan.spanContext.traceId,
+        spanId: stackParentSpan.spanContext.spanId,
+        parentSpanId: stackParentSpan.spanContext.parentSpanId
+      };
+      return;
+    }
     this.currentContext = undefined;
   }
 }
@@ -285,7 +367,10 @@ class OTelTracerProvider {
   storage;
   initialized = false;
   globalContext;
+  instanceId;
   constructor(storage, dbPath) {
+    providerCounter++;
+    this.instanceId = `Provider#${providerCounter}`;
     this.storage = storage || new SQLiteSpanStorage(dbPath || getDefaultDbPath());
   }
   async initialize() {
@@ -358,7 +443,7 @@ function getDefaultDbPath() {
   const dataHome = process.env.XDG_DATA_HOME || path.join(home, ".local", "share");
   return path.join(dataHome, "roy-agent", "traces.db");
 }
-var providerInstance = null;
+var providerInstance = null, providerCounter = 0;
 var init_tracer_provider = __esm(() => {
   init_span_storage();
   init_propagation();

package/dist/shared/@ai-setting/{roy-agent-core-np1w5dpe.js → roy-agent-core-728h32vx.js}

@@ -1,22 +1,45 @@
+import {
+  TaskTagPlugin,
+  createLarkCliTaskNotifyHook
+} from "./roy-agent-core-2x07feb7.js";
 import {
   envKeyToConfigKey
 } from "./roy-agent-core-qxhq8ven.js";
 import {
   BaseComponent
-} from "./roy-agent-core-cefh9hjv.js";
+} from "./roy-agent-core-4jqq077c.js";
 import {
   globalHookManager
-} from "./roy-agent-core-86gphny5.js";
+} from "./roy-agent-core-jqy2mdyq.js";
+import {
+  createEnvContext,
+  runWithEnvContext
+} from "./roy-agent-core-z33en0cz.js";
 import {
   createLogger,
   init_logger
-} from "./roy-agent-core-44hnfb02.js";
+} from "./roy-agent-core-10n2jh7p.js";
+import {
+  getTracerProvider
+} from "./roy-agent-core-58k274fg.js";
 import {
   __require
 } from "./roy-agent-core-fs0mn2jk.js";
 
 // src/env/event-source/event-source-handlers.ts
 import { spawn } from "child_process";
+var BUILT_IN_PLUGIN_FACTORIES = {
+  LarkCliTaskNotifyPlugin: (cfg) => createLarkCliTaskNotifyHook(cfg),
+  "task-tag": () => new TaskTagPlugin
+};
+function generateTraceId() {
+  const chars = "0123456789abcdef";
+  let traceId = "";
+  for (let i = 0;i < 32; i++) {
+    traceId += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return traceId;
+}
 function matchEventType(eventType, patterns) {
   for (const pattern of patterns) {
     if (pattern === "*")
@@ -35,28 +58,41 @@ function extractMetadata(rawEvent, eventType) {
   const event = rawEvent;
   const metadata = {};
   const larkInnerEvent = event.event;
-  const header = event.header;
-  const message = larkInnerEvent?.message || event.message;
+  const header = larkInnerEvent?.header || event.header;
   const sender = larkInnerEvent?.sender || event.sender;
   const senderId = sender?.sender_id;
+  let messageData;
+  if (larkInnerEvent?.message) {
+    messageData = larkInnerEvent.message;
+  } else if (typeof event.message === "object" && event.message !== null) {
+    messageData = event.message;
+  } else {
+    messageData = {
+      message_id: event.message_id || event.id,
+      chat_id: event.chat_id,
+      chat_type: event.chat_type,
+      message_type: event.message_type,
+      content: event.content
+    };
+  }
   if (header) {
     metadata.eventType = header.event_type;
     metadata.appId = header.app_id;
     metadata.tenantKey = header.tenant_key;
   }
-  if (message) {
-    metadata.chatId = message.chat_id;
-    metadata.chatType = message.chat_type;
-    metadata.messageId = message.message_id;
-    metadata.messageType = message.message_type;
+  if (messageData) {
+    metadata.chatId = messageData.chat_id;
+    metadata.chatType = messageData.chat_type;
+    metadata.messageId = messageData.message_id;
+    metadata.messageType = messageData.message_type;
   }
   if (senderId) {
     metadata.senderId = senderId.open_id || senderId.user_id || senderId.union_id;
   }
   let recommendedAction;
-  if (eventType === "im.message.receive_v1") {
+  if (eventType === "im.message.receive_v1" || event.type === "im.message.receive_v1") {
     recommendedAction = {
-      action: "处理飞书消息并以机器人身份回复",
+      action: '处理飞书消息并以机器人身份回复，比如lark-cli im +messages-reply --message-id "xxxxid" --as bot --text "回复内容"',
       replyTo: {
         appId: metadata.appId,
         chatId: metadata.chatId,
@@ -67,8 +103,8 @@ function extractMetadata(rawEvent, eventType) {
   const replyChannel = {
     type: "lark-cli",
     appId: metadata.appId,
-    chatId: metadata.chatId,
-    messageId: metadata.messageId
+    chatId: messageData?.chat_id,
+    messageId: messageData?.message_id
   };
   return { metadata, replyChannel, recommendedAction };
 }
@@ -164,39 +200,107 @@ class LarkCliInstance {
     for (const pluginName of plugins) {
       const plugin = await this.importPlugin(pluginName);
       if (plugin) {
+        const hookPoints = this.getPluginHookPoints(plugin);
         this.registerPluginHooks(plugin);
         this.loadedPlugins.push({
           name: pluginName,
-          hooks: plugin.hooks.map((h) => ({ point: h.point, name: `${pluginName}:${h.point}` }))
+          hooks: hookPoints.map((h) => ({ point: h, name: `${pluginName}:${h}` }))
         });
       }
     }
   }
+  getPluginHookPoints(plugin) {
+    if (Array.isArray(plugin.hooks)) {
+      return plugin.hooks.map((h) => h.point || h);
+    }
+    if (typeof plugin.execute === "function" && plugin.hookPoint) {
+      return [plugin.hookPoint];
+    }
+    if (plugin.name && typeof plugin.execute === "function") {
+      return ["task:after.create", "task:after.update"];
+    }
+    return [];
+  }
   async importPlugin(name) {
-    const PLUGIN_PATHS = {
-      "task-tag": "@ai-setting/roy-agent-core/env/task/plugins/task-tag-plugin"
-    };
-    const path = PLUGIN_PATHS[name] || name;
+    const factory = BUILT_IN_PLUGIN_FACTORIES[name];
+    if (!factory) {
+      console.error(`[LarkCliInstance] Unknown plugin: ${name}`);
+      return null;
+    }
     try {
-      const module = await import(path);
-      const PluginClass = module.TaskPlugin || module.default;
-      return new PluginClass;
+      return factory({
+        sourceId: this.config.id,
+        pluginName: name
+      });
     } catch (error) {
-      console.error(`[LarkCliInstance] Failed to load plugin ${name}:`, error);
+      console.error(`[LarkCliInstance] Failed to instantiate plugin ${name}:`, error);
       return null;
     }
   }
   registerPluginHooks(plugin) {
-    for (const hook of plugin.hooks) {
-      globalHookManager.register(hook.point, {
-        name: `${plugin.name}:${hook.point}`,
-        priority: hook.priority ?? 0,
-        pluginName: plugin.name,
-        sourceId: this.config.id,
-        execute: async (ctx) => {
-          await plugin.execute(ctx);
+    const pluginName = plugin.name || "unknown";
+    if (typeof plugin.init === "function") {
+      const pluginEnv = {
+        getComponent: () => null,
+        registerAgent: () => {},
+        registerTool: () => {},
+        registerHook: (hook) => {
+          globalHookManager.register(hook.point, {
+            name: `${pluginName}:${hook.point}`,
+            priority: hook.priority ?? 0,
+            pluginName,
+            sourceId: this.config.id,
+            execute: hook.handler
+          });
+        },
+        logger: {
+          debug: (...args) => console.debug(`[plugin:${pluginName}]`, ...args),
+          info: (...args) => console.info(`[plugin:${pluginName}]`, ...args),
+          warn: (...args) => console.warn(`[plugin:${pluginName}]`, ...args),
+          error: (...args) => console.error(`[plugin:${pluginName}]`, ...args)
         }
-      });
+      };
+      plugin.init(pluginEnv);
+      return;
+    }
+    if (typeof plugin.execute === "function") {
+      if (plugin.hookPoint) {
+        globalHookManager.register(plugin.hookPoint, {
+          name: `${pluginName}:${plugin.hookPoint}`,
+          priority: plugin.priority ?? 0,
+          pluginName,
+          sourceId: this.config.id,
+          execute: plugin.execute
+        });
+      } else {
+        const hookPoints = this.getPluginHookPoints(plugin);
+        for (const hookPoint of hookPoints) {
+          globalHookManager.register(hookPoint, {
+            name: `${pluginName}:${hookPoint}`,
+            priority: plugin.priority ?? 0,
+            pluginName,
+            sourceId: this.config.id,
+            execute: plugin.execute.bind(plugin)
+          });
+        }
+      }
+      return;
+    }
+    if (Array.isArray(plugin.hooks)) {
+      for (const hook of plugin.hooks) {
+        const hookPoint = hook.point || hook;
+        const priority = hook.priority ?? 0;
+        globalHookManager.register(hookPoint, {
+          name: `${pluginName}:${hookPoint}`,
+          priority,
+          pluginName,
+          sourceId: this.config.id,
+          execute: async (ctx) => {
+            await plugin.execute(ctx);
+          }
+        });
+      }
+      return;
     }
   }
   unloadPlugins() {
@@ -219,6 +323,20 @@ class LarkCliInstance {
     }
   }
   handleEvent(rawData) {
+    const provider = getTracerProvider();
+    const tracer = provider.getTracer("roy-tracer");
+    const rootTraceId = generateTraceId();
+    const rootSpanId = tracer.generateSpanId();
+    const rootContext = {
+      traceId: rootTraceId,
+      spanId: rootSpanId,
+      parentSpanId: undefined
+    };
+    const rootSpan = tracer.startSpan("lark-cli.handleEvent", {
+      context: rootContext,
+      attributes: { rawData: rawData.substring(0, 500) }
+    });
+    provider.setGlobalContext(rootSpan.spanContext);
     try {
       let rawEvent;
       try {
@@ -241,8 +359,16 @@ class LarkCliInstance {
         return;
       }
       const { metadata, replyChannel, recommendedAction } = extractMetadata(rawEvent, eventType);
-      const message = rawData;
+      const message = JSON.stringify({
+        rawData,
+        recommendedAction
+      });
       const timestamp = Date.now();
+      const plugins = this.config.handleRule?.plugins || [];
+      const pluginEnabled = {};
+      for (const pluginName of plugins) {
+        pluginEnabled[`${this.config.id}:${pluginName}`] = true;
+      }
       const evt = {
         id: `es-${this.config.id}-${timestamp}`,
         type: "event-source.event.lark-cli",
@@ -250,7 +376,10 @@ class LarkCliInstance {
         metadata: {
           source: "event-source",
           sourceId: this.config.id,
-          sourceMessageType: eventType
+          sourceMessageType: eventType,
+          plugins,
+          pluginEnabled,
+          replyChannel
         },
         payload: {
           sourceId: this.config.id,
@@ -263,10 +392,114 @@ class LarkCliInstance {
           timestamp
         }
       };
-      this.eventHandler?.(evt);
+      const userId = this.extractUserId(rawEvent);
+      const envReplyChannel = this.buildReplyChannel(replyChannel);
+      const envContext = createEnvContext({
+        envEvent: evt,
+        sourceId: this.config.id,
+        userId,
+        replyChannel: envReplyChannel,
+        pluginEnabled,
+        plugins
+      });
+      runWithEnvContext(envContext, () => {
+        this.eventHandler?.(evt);
+      });
     } catch (error) {
       console.error(`[LarkCliInstance] Error handling event: ${error}`);
+      rootSpan.setAttribute("error", String(error));
+    } finally {
+      rootSpan.end();
+    }
+  }
+  extractUserId(rawEvent) {
+    const event = rawEvent;
+    const innerEvent = event.event;
+    const message = innerEvent?.message || event.message;
+    const sender = innerEvent?.sender || event.sender || message?.sender;
+    const senderId = sender?.sender_id;
+    return senderId?.open_id || senderId?.user_id || senderId?.union_id || "unknown";
+  }
+  buildReplyChannel(replyChannel) {
+    if (!replyChannel || !replyChannel.chatId && !replyChannel.messageId) {
+      return;
     }
+    return {
+      type: replyChannel.type,
+      messageId: replyChannel.messageId,
+      chatId: replyChannel.chatId,
+      userId: replyChannel.params?.userId,
+      identity: "bot",
+      sendText: async (text) => {
+        await this.sendLarkMessage({
+          chatId: replyChannel.chatId,
+          userId: replyChannel.params?.userId,
+          content: text,
+          as: "bot"
+        });
+      },
+      sendMarkdown: async (markdown) => {
+        await this.sendLarkMessage({
+          chatId: replyChannel.chatId,
+          userId: replyChannel.params?.userId,
+          content: markdown,
+          as: "bot"
+        });
+      },
+      sendMessage: async (content) => {
+        await this.sendLarkMessage({
+          chatId: replyChannel.chatId,
+          userId: replyChannel.params?.userId,
+          content: JSON.stringify(content),
+          as: "bot"
+        });
+      },
+      reply: async (content) => {
+        if (replyChannel.messageId) {
+          await this.sendLarkMessage({
+            messageId: replyChannel.messageId,
+            content: JSON.stringify(content),
+            as: "bot"
+          });
+        }
+      }
+    };
+  }
+  async sendLarkMessage(options) {
+    return new Promise((resolve, reject) => {
+      const { chatId, userId, messageId, content, as: identity } = options;
+      const args = ["im", "+messages-send", "--as", identity];
+      if (messageId) {
+        args.push("+messages-reply", "--message-id", messageId, "--text", content);
+      } else if (chatId) {
+        args.push("--chat-id", chatId, "--text", content);
+      } else if (userId) {
+        args.push("--user-id", userId, "--text", content);
+      } else {
+        reject(new Error("No target specified for sending message"));
+        return;
+      }
+      const proc = spawn("lark-cli", args, {
+        shell: false,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      proc.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+      proc.stderr?.on("data", (data) => {
+        stderr += data.toString();
+      });
+      proc.on("close", (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`lark-cli exited with code ${code}: ${stderr}`));
+        }
+      });
+      proc.on("error", reject);
+    });
   }
 }
 var larkCliHandler = {

package/dist/shared/@ai-setting/{roy-agent-core-jfh9q2qh.js → roy-agent-core-7b35emr7.js}

@@ -1,13 +1,4 @@
-import {
-  TracedAs,
-  init_decorator
-} from "./roy-agent-core-zgypchmt.js";
-import {
-  __legacyDecorateClassTS
-} from "./roy-agent-core-fs0mn2jk.js";
-
 // src/env/session/session-message-converter.ts
-init_decorator();
 import { randomUUID } from "crypto";
 var DEFAULT_REASONING_BUDGET_TOKENS = 1e4;
 
@@ -194,11 +185,5 @@ class SessionMessageConverter {
     };
   }
 }
-__legacyDecorateClassTS([
-  TracedAs("session-message-converter.toModelMessage", { recordParams: true, recordResult: true, log: true })
-], SessionMessageConverter.prototype, "toModelMessage", null);
-__legacyDecorateClassTS([
-  TracedAs("session-message-converter.fromModelMessage", { recordParams: true, recordResult: true, log: true })
-], SessionMessageConverter.prototype, "fromModelMessage", null);
 
 export { SessionMessageConverter };

package/dist/shared/@ai-setting/{roy-agent-core-3rr5k71j.js → roy-agent-core-8n4bz6y3.js}

@@ -1,6 +1,6 @@
 import {
   getDatabase
-} from "./roy-agent-core-zpn0bqa8.js";
+} from "./roy-agent-core-9ffsvvcf.js";
 import {
   exports_search_query_parser,
   init_search_query_parser

package/dist/shared/@ai-setting/{roy-agent-core-zpn0bqa8.js → roy-agent-core-9ffsvvcf.js}

@@ -1,7 +1,7 @@
 import {
   createLogger,
   init_logger
-} from "./roy-agent-core-44hnfb02.js";
+} from "./roy-agent-core-10n2jh7p.js";
 import {
   __require
 } from "./roy-agent-core-fs0mn2jk.js";

package/dist/shared/@ai-setting/roy-agent-core-az13yzmc.js

@@ -0,0 +1,11 @@
+// src/env/plugin/types.ts
+class BasePlugin {
+  version = "1.0.0";
+  description;
+  priority = 0;
+  constructor() {}
+  init(env) {}
+  dispose() {}
+}
+
+export { BasePlugin };