@astrive-ai/agent 1.0.0

package/dist/reflection.js

@@ -0,0 +1,51 @@
+export class ReflectionEngine {
+    async reflect(response, context) {
+        const review = await this.reviewResponse(response, context.provider);
+        if (review.hasIssues) {
+            const prompt = `The previous response to "${context.originalInput}" had issues. Please improve it based on this feedback:
+Issues: ${review.issues.join(", ")}
+Suggestions: ${review.suggestions.join(", ")}
+Original response: ${response}
+
+Please provide the corrected response.`;
+            const improvedResponse = await context.provider.chat({
+                messages: [
+                    { role: "system", content: "You are an expert editor who improves responses based on feedback. Provide ONLY the improved response." },
+                    { role: "user", content: prompt }
+                ],
+                model: "llama-3.3-70b-versatile"
+            });
+            return improvedResponse.content || response;
+        }
+        return response;
+    }
+    async reviewResponse(response, provider) {
+        const prompt = `Review the following response for accuracy, clarity, and completeness.
+Response: "${response}"
+
+Provide your review in the following JSON format ONLY:
+{
+  "hasIssues": boolean,
+  "issues": ["list of specific issues"],
+  "suggestions": ["list of actionable suggestions to fix issues"]
+}`;
+        try {
+            const reviewResponse = await provider.chat({
+                messages: [
+                    { role: "system", content: "You are a critical reviewer. Always respond with valid JSON matching the requested schema." },
+                    { role: "user", content: prompt }
+                ],
+                model: "llama-3.3-70b-versatile"
+            });
+            const content = (reviewResponse.content || "").trim();
+            const jsonStart = content.indexOf('{');
+            const jsonEnd = content.lastIndexOf('}') + 1;
+            const jsonString = content.slice(jsonStart, jsonEnd);
+            return JSON.parse(jsonString);
+        }
+        catch (e) {
+            return { hasIssues: false, issues: [], suggestions: [] };
+        }
+    }
+}
+//# sourceMappingURL=reflection.js.map

package/dist/reflection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflection.js","sourceRoot":"","sources":["../src/reflection.ts"],"names":[],"mappings":"AAaA,MAAM,OAAO,gBAAgB;IACpB,KAAK,CAAC,OAAO,CAAC,QAAgB,EAAE,OAA0B;QAC/D,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;QAErE,IAAI,MAAM,CAAC,SAAS,EAAE,CAAC;YACrB,MAAM,MAAM,GAAG,6BAA6B,OAAO,CAAC,aAAa;UAC7D,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;eACnB,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC;qBACvB,QAAQ;;uCAEU,CAAC;YAElC,MAAM,gBAAgB,GAAG,MAAM,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;gBACnD,QAAQ,EAAE;oBACR,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,wGAAwG,EAAE;oBACrI,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE;iBAClC;gBACD,KAAK,EAAE,yBAAyB;aACjC,CAAC,CAAC;YAEH,OAAO,gBAAgB,CAAC,OAAO,IAAI,QAAQ,CAAC;QAC9C,CAAC;QAED,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEO,KAAK,CAAC,cAAc,CAAC,QAAgB,EAAE,QAAmB;QAChE,MAAM,MAAM,GAAG;aACN,QAAQ;;;;;;;EAOnB,CAAC;QAEC,IAAI,CAAC;YACH,MAAM,cAAc,GAAG,MAAM,QAAQ,CAAC,IAAI,CAAC;gBACzC,QAAQ,EAAE;oBACR,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,4FAA4F,EAAE;oBACzH,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE;iBAClC;gBACD,KAAK,EAAE,yBAAyB;aACjC,CAAC,CAAC;YAEH,MAAM,OAAO,GAAG,CAAC,cAAc,CAAC,OAAO,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC;YACtD,MAAM,SAAS,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YACvC,MAAM,OAAO,GAAG,OAAO,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YAC7C,MAAM,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;YAErD,OAAO,IAAI,CAAC,KAAK,CAAC,UAAU,CAAiB,CAAC;QAChD,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC;QAC3D,CAAC;IACH,CAAC;CACF"}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@astrive-ai/agent",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@astrive-ai/types": "*",
+    "@astrive-ai/logger": "*",
+    "@astrive-ai/events": "*",
+    "@astrive-ai/core": "*",
+    "@astrive-ai/providers": "*",
+    "@astrive-ai/planner": "*",
+    "@astrive-ai/memory": "*",
+    "@astrive-ai/tools": "*"
+  },
+  "devDependencies": {
+    "typescript": "5.4.5"
+  }
+}

package/src/astrive-ai.ts

@@ -0,0 +1,357 @@
+import { 
+  AstriveConfig, 
+  IAgent, 
+  ChatInput, 
+  ChatOptions, 
+  AgentResponse, 
+  AgentStreamChunk, 
+  IPlugin, 
+  ITool,
+  PluginContext,
+  IProvider,
+  Message,
+  ResponseMetadata,
+  ToolDefinition,
+  ToolResult
+} from "@astrive-ai/types";
+import { Logger } from "@astrive-ai/logger";
+import { EventEmitter } from "@astrive-ai/events";
+import { ProviderManager, GroqProvider } from "@astrive-ai/providers";
+import { ToolRegistry, MiddlewarePipeline, ToolExecutor } from "@astrive-ai/core";
+import { MemoryManager } from "@astrive-ai/memory";
+import { LLMPlanner, SimplePlanner } from "@astrive-ai/planner";
+import * as BuiltInTools from "@astrive-ai/tools";
+import { ConversationManager } from "./conversation-manager.js";
+import { PluginManager } from "./plugin-manager.js";
+import { ReflectionEngine } from "./reflection.js";
+import { randomUUID } from "node:crypto";
+
+type ToolFactory = () => ITool;
+
+export class AstriveAI implements IAgent {
+  private config: AstriveConfig;
+  private logger: Logger;
+  private events: EventEmitter;
+  private providerManager: ProviderManager;
+  private toolRegistry: ToolRegistry;
+  private memoryManager: MemoryManager;
+  private middlewarePipeline: MiddlewarePipeline;
+  private toolExecutor: ToolExecutor;
+  private planner: LLMPlanner | SimplePlanner;
+  private conversationManager: ConversationManager;
+  private pluginManager: PluginManager;
+  private reflectionEngine: ReflectionEngine;
+  private initialized = false;
+
+  constructor(config: AstriveConfig) {
+    this.config = config;
+    this.logger = new Logger(config.logger || { level: 'info', prefix: 'Astrive', colors: true, timestamp: true });
+    this.events = new EventEmitter();
+    
+    this.providerManager = new ProviderManager();
+    if (config.providers?.groq?.apiKey) {
+      const groq = new GroqProvider(this.logger, this.events);
+      this.providerManager.register(groq);
+    }
+    
+    this.toolRegistry = new ToolRegistry(this.events);
+    
+    const toolClasses = [
+      BuiltInTools.DownloaderTool,
+      BuiltInTools.VisionTool,
+      BuiltInTools.TextToImageTool,
+      BuiltInTools.RemoveBGTool,
+      BuiltInTools.UpscalerTool,
+      BuiltInTools.OCRTool,
+      BuiltInTools.FaceSwapTool,
+      BuiltInTools.Img2ImgTool,
+      BuiltInTools.TextToSpeechTool,
+      BuiltInTools.SpeechToTextTool,
+      BuiltInTools.WebSearchTool,
+      BuiltInTools.FilesystemTool,
+      BuiltInTools.TerminalTool,
+      BuiltInTools.GitTool,
+    ];
+    for (const ToolClass of toolClasses) {
+      if (ToolClass) {
+        this.toolRegistry.register(new ToolClass());
+      }
+    }
+
+    this.memoryManager = new MemoryManager(config.memory || {}, this.logger, this.events);
+    this.middlewarePipeline = new MiddlewarePipeline();
+    this.toolExecutor = new ToolExecutor(this.toolRegistry, this.events, this.logger);
+    
+    this.conversationManager = new ConversationManager();
+    this.pluginManager = new PluginManager();
+    this.reflectionEngine = new ReflectionEngine();
+    
+    this.planner = new SimplePlanner();
+    
+    this.initialized = true;
+  }
+
+  public async init() {
+    await this.providerManager.initAll(this.config.providers || {});
+    const providers = this.providerManager.getAll();
+    if (providers.length > 0) {
+      this.planner = new LLMPlanner(providers[0], this.logger, this.events);
+    }
+  }
+
+  public async chat(input: string | ChatInput, options?: ChatOptions): Promise<AgentResponse> {
+    if (!this.initialized) {
+      throw new Error("Agent not initialized");
+    }
+    
+    const startTime = Date.now();
+    const chatInput: ChatInput = typeof input === "string" ? { message: input, sessionId: (options as any)?.sessionId } : input;
+    const sessionId = chatInput.sessionId || "default";
+    
+    let providerName = "groq";
+    if (options && 'provider' in options && options.provider) {
+      providerName = options.provider;
+    }
+    
+    let provider: IProvider;
+    try {
+      provider = this.providerManager.selectProvider(providerName, "chat");
+    } catch (e) {
+      const providers = this.providerManager.getAll();
+      if (providers.length > 0) {
+        provider = providers[0];
+      } else {
+        throw new Error(`Provider ${providerName} not found`);
+      }
+    }
+
+    this.conversationManager.addMessage(sessionId, { role: "user", content: chatInput.message });
+    
+    let memoryContext = "";
+    if (this.config.memory?.enabled) {
+      memoryContext = await this.memoryManager.getRelevantContext(chatInput.message, 5);
+    }
+
+    const messages = this.conversationManager.buildMessages(sessionId, this.config.systemPrompt, memoryContext);
+    const tools = this.toolRegistry.getAll();
+    const toolDefinitions = this.toolRegistry.getDefinitions();
+
+    let response: AgentResponse;
+    const planningEnabled = options?.planning !== false && tools.length > 0;
+    let stepsExecuted = 0;
+    
+    const callProvider = async (msgs: Message[], toolsList?: ToolDefinition[]) => {
+      return await provider.chat({
+        messages: msgs,
+        model: options?.model || "llama-3.3-70b-versatile",
+        temperature: options?.temperature || 0.7,
+        maxTokens: options?.maxTokens || 2048,
+        tools: toolsList && toolsList.length > 0 ? toolsList : undefined
+      });
+    };
+
+    if (planningEnabled) {
+      const initialResponse = await callProvider(messages, toolDefinitions);
+      stepsExecuted++;
+      
+      if (initialResponse.toolCalls && initialResponse.toolCalls.length > 0) {
+        const toolResults = [];
+
+        const assistantMessage: Message = { 
+          role: "assistant", 
+          content: initialResponse.content || "",
+          tool_calls: initialResponse.toolCalls as any
+        };
+        messages.push(assistantMessage);
+        this.conversationManager.addMessage(sessionId, assistantMessage);
+
+        for (const call of initialResponse.toolCalls) {
+          try {
+            const args = typeof call.arguments === 'string' 
+              ? JSON.parse(call.arguments) 
+              : call.arguments;
+            
+            const result = await this.toolExecutor.execute({
+              id: call.id,
+              name: call.name,
+              arguments: args
+            });
+            const finalToolResult: ToolResult = result.result || { success: false, data: result.error, contentType: 'text' };
+            toolResults.push(finalToolResult);
+            
+            const toolMsg: Message = {
+              role: "tool",
+              content: JSON.stringify(result.result || { error: result.error }),
+              tool_call_id: call.id
+            };
+            messages.push(toolMsg);
+            this.conversationManager.addMessage(sessionId, toolMsg);
+            stepsExecuted++;
+          } catch (error) {
+            const toolMsg: Message = {
+              role: "tool",
+              content: JSON.stringify({ error: (error as Error).message }),
+              tool_call_id: call.id
+            };
+            messages.push(toolMsg);
+            this.conversationManager.addMessage(sessionId, toolMsg);
+            stepsExecuted++;
+          }
+        }
+
+        const finalResponse = await callProvider(messages);
+        stepsExecuted++;
+        
+        const metadata: ResponseMetadata = {
+          conversationId: sessionId,
+          model: finalResponse.model,
+          provider: provider.name,
+          executionTime: Date.now() - startTime,
+          stepsExecuted
+        };
+
+        response = {
+          content: finalResponse.content,
+          toolResults,
+          usage: finalResponse.usage,
+          metadata
+        };
+        
+        this.conversationManager.addMessage(sessionId, { role: "assistant", content: response.content });
+      } else {
+        const metadata: ResponseMetadata = {
+          conversationId: sessionId,
+          model: initialResponse.model,
+          provider: provider.name,
+          executionTime: Date.now() - startTime,
+          stepsExecuted
+        };
+
+        response = {
+          content: initialResponse.content,
+          usage: initialResponse.usage,
+          metadata
+        };
+        this.conversationManager.addMessage(sessionId, { role: "assistant", content: response.content });
+      }
+    } else {
+      const rawResponse = await callProvider(messages);
+      stepsExecuted++;
+      const metadata: ResponseMetadata = {
+        conversationId: sessionId,
+        model: rawResponse.model,
+        provider: provider.name,
+        executionTime: Date.now() - startTime,
+        stepsExecuted
+      };
+
+      response = {
+        content: rawResponse.content,
+        usage: rawResponse.usage,
+        metadata
+      };
+      this.conversationManager.addMessage(sessionId, { role: "assistant", content: response.content });
+    }
+
+    if (this.config.memory?.enabled) {
+      await this.memoryManager.extractAndSaveMemories([{ role: "user", content: chatInput.message }, { role: "assistant", content: response.content }]);
+    }
+
+    return response;
+  }
+
+  public async *chatStream(input: string | ChatInput, options?: ChatOptions): AsyncGenerator<AgentStreamChunk> {
+    if (!this.initialized) {
+      throw new Error("Agent not initialized");
+    }
+
+    const chatInput = typeof input === "string" ? { message: input, sessionId: (options as any)?.sessionId } : input;
+    const sessionId = chatInput.sessionId || "default";
+    
+    let providerName = "groq";
+    if (options && 'provider' in options && options.provider) {
+      providerName = options.provider;
+    }
+    
+    let provider: IProvider;
+    try {
+      provider = this.providerManager.selectProvider(providerName, "chat");
+    } catch (e) {
+      const providers = this.providerManager.getAll();
+      if (providers.length > 0) provider = providers[0];
+      else throw new Error(`Provider ${providerName} not found`);
+    }
+
+    this.conversationManager.addMessage(sessionId, { role: "user", content: chatInput.message });
+    const messages = this.conversationManager.buildMessages(sessionId, this.config.systemPrompt);
+    
+    if (!provider.chatStream) throw new Error("Provider does not support streaming");
+    const stream = await provider.chatStream({
+      messages,
+      model: options?.model || "llama-3.3-70b-versatile",
+      temperature: options?.temperature || 0.7,
+      maxTokens: options?.maxTokens || 2048
+    });
+
+    let fullContent = "";
+
+    for await (const chunk of stream) {
+      if (chunk.content) {
+        fullContent += chunk.content;
+        yield { type: "text", content: chunk.content };
+      }
+    }
+
+    this.conversationManager.addMessage(sessionId, { role: "assistant", content: fullContent });
+    yield { type: "done" };
+  }
+
+  public async use(plugin: IPlugin): Promise<void> {
+    const context: PluginContext = {
+      agent: this,
+      config: this.config as any,
+      logger: this.logger,
+      events: this.events,
+      registerTool: (t) => this.toolRegistry.register(t),
+      registerProvider: (p) => this.providerManager.register(p),
+      registerMiddleware: (m) => this.middlewarePipeline.use(m)
+    };
+    await this.pluginManager.install(plugin, context);
+  }
+
+  public provider(provider: IProvider): void {
+    this.providerManager.register(provider);
+  }
+
+  public tool(tool: ITool | ToolFactory): void {
+    if (typeof tool === 'function') {
+      this.toolRegistry.register(tool());
+    } else {
+      this.toolRegistry.register(tool);
+    }
+  }
+
+  public getTools(): ITool[] {
+    return this.toolRegistry.getAll();
+  }
+
+  public getProviders(): IProvider[] {
+    return this.providerManager.getAll();
+  }
+
+  public async destroy(): Promise<void> {
+    await this.pluginManager.destroyAll();
+    
+    for (const provider of this.providerManager.getAll()) {
+      if (typeof (provider as any).destroy === 'function') {
+        await (provider as any).destroy();
+      }
+    }
+    
+    this.initialized = false;
+  }
+}
+
+export function createAgent(config: AstriveConfig): IAgent {
+  return new AstriveAI(config);
+}

package/src/conversation-manager.ts

@@ -0,0 +1,67 @@
+import { Message } from "@astrive-ai/types";
+import { randomUUID } from "node:crypto";
+
+export interface ConversationState {
+  id: string;
+  messages: Message[];
+  systemPrompt?: string;
+  metadata?: Record<string, any>;
+  createdAt: number;
+}
+
+export class ConversationManager {
+  private conversations: Map<string, ConversationState> = new Map();
+
+  public getOrCreate(sessionId?: string, systemPrompt?: string): ConversationState {
+    const id = sessionId || randomUUID();
+    let state = this.conversations.get(id);
+
+    if (!state) {
+      state = {
+        id,
+        messages: [],
+        systemPrompt,
+        createdAt: Date.now(),
+      };
+      this.conversations.set(id, state);
+    }
+
+    if (systemPrompt && state.systemPrompt !== systemPrompt) {
+      state.systemPrompt = systemPrompt;
+    }
+
+    return state;
+  }
+
+  public addMessage(id: string, message: Message): void {
+    const state = this.conversations.get(id);
+    if (state) {
+      state.messages.push(message);
+    }
+  }
+
+  public getMessages(id: string): Message[] {
+    const state = this.conversations.get(id);
+    return state ? [...state.messages] : [];
+  }
+
+  public buildMessages(id: string, systemPrompt?: string, memoryContext?: string): Message[] {
+    const state = this.getOrCreate(id, systemPrompt);
+    const messages: Message[] = [];
+
+    const finalSystemPrompt = memoryContext
+      ? `${state.systemPrompt || "You are a helpful AI assistant."}\n\nContext:\n${memoryContext}`
+      : state.systemPrompt;
+
+    if (finalSystemPrompt) {
+      messages.push({ role: "system", content: finalSystemPrompt });
+    }
+
+    // Add all messages to the context. Tool messages and tool_calls are correctly maintained in the array.
+    for (const msg of state.messages) {
+      messages.push({ ...msg });
+    }
+
+    return messages;
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from "./astrive-ai.js";
+export * from "./conversation-manager.js";
+export * from "./plugin-manager.js";
+export * from "./reflection.js";
+export * from "./multi-agent.js";

package/src/multi-agent.ts

@@ -0,0 +1,75 @@
+import { IAgent, ChatInput, AgentResponse, ChatOptions } from '@astrive-ai/types';
+
+export interface AgentTask {
+  description: string;
+  assignedRole: 'researcher' | 'coder' | 'creative' | 'reviewer' | 'validator' | 'custom';
+  dependencies?: string[];
+}
+
+export class MultiAgentOrchestrator {
+  private agents: Map<string, IAgent> = new Map();
+  private plannerAgent: IAgent;
+
+  constructor(plannerAgent: IAgent) {
+    this.plannerAgent = plannerAgent;
+  }
+
+  public registerAgent(role: string, agent: IAgent): void {
+    this.agents.set(role, agent);
+  }
+
+  public async executeTask(task: string, options?: ChatOptions): Promise<AgentResponse> {
+    // 1. Planning phase
+    const planPrompt = `Break down the following task into sub-tasks assigned to different agent roles (researcher, coder, creative). Output JSON only.\nTask: ${task}`;
+    const planResponse = await this.plannerAgent.chat(planPrompt, { ...options, planning: false });
+    
+    // In a real implementation, we would parse the JSON plan and execute the subtasks.
+    // For this prototype, we'll assume a linear flow if specific roles are registered.
+    
+    let currentContext = `Original Task: ${task}\n\n`;
+    let finalResponse: AgentResponse | null = null;
+    
+    // 2. Execution phase - Researcher
+    if (this.agents.has('researcher')) {
+      const researcher = this.agents.get('researcher')!;
+      const res = await researcher.chat(`Research the following task and provide context:\n${currentContext}`, options);
+      currentContext += `Research Results:\n${res.content}\n\n`;
+      finalResponse = res;
+    }
+    
+    // 3. Execution phase - Coder or Creative
+    if (this.agents.has('coder')) {
+      const coder = this.agents.get('coder')!;
+      const res = await coder.chat(`Based on the context, write the necessary code:\n${currentContext}`, options);
+      currentContext += `Code Results:\n${res.content}\n\n`;
+      finalResponse = res;
+    } else if (this.agents.has('creative')) {
+      const creative = this.agents.get('creative')!;
+      const res = await creative.chat(`Based on the context, create the required content:\n${currentContext}`, options);
+      currentContext += `Creative Results:\n${res.content}\n\n`;
+      finalResponse = res;
+    }
+    
+    // 4. Review phase
+    if (this.agents.has('reviewer')) {
+      const reviewer = this.agents.get('reviewer')!;
+      const res = await reviewer.chat(`Review the following results and suggest improvements:\n${currentContext}`, options);
+      currentContext += `Review Results:\n${res.content}\n\n`;
+      finalResponse = res;
+    }
+    
+    // 5. Validation and Final Polish phase
+    if (this.agents.has('validator')) {
+      const validator = this.agents.get('validator')!;
+      const res = await validator.chat(`Validate the work and provide the final output to the user:\n${currentContext}`, options);
+      finalResponse = res;
+    }
+
+    if (!finalResponse) {
+      // Fallback if no specialized agents were registered
+      return await this.plannerAgent.chat(task, options);
+    }
+
+    return finalResponse;
+  }
+}

package/src/plugin-manager.ts

@@ -0,0 +1,42 @@
+import { IPlugin, PluginContext } from "@astrive-ai/types";
+
+export class PluginManager {
+  private plugins: Map<string, IPlugin> = new Map();
+
+  public async install(plugin: IPlugin, context: PluginContext): Promise<void> {
+    if (this.plugins.has(plugin.name)) {
+      throw new Error(`Plugin ${plugin.name} is already installed`);
+    }
+
+    await plugin.install(context);
+    this.plugins.set(plugin.name, plugin);
+    
+    if (plugin.onInit) {
+      await plugin.onInit();
+    }
+  }
+
+  public async uninstall(name: string): Promise<void> {
+    const plugin = this.plugins.get(name);
+    if (plugin) {
+      if (plugin.onDestroy) {
+        await plugin.onDestroy();
+      }
+      this.plugins.delete(name);
+    }
+  }
+
+  public async destroyAll(): Promise<void> {
+    for (const name of Array.from(this.plugins.keys())) {
+      await this.uninstall(name);
+    }
+  }
+
+  public getAll(): IPlugin[] {
+    return Array.from(this.plugins.values());
+  }
+
+  public has(name: string): boolean {
+    return this.plugins.has(name);
+  }
+}