PluginRegistry

import { PluginRegistry } from '@frontmcp/sdk';

// Access via scope
const plugins = scope.plugins;

// List all plugins
const allPlugins = plugins.getPlugins();

getPlugins(): ReadonlyArray<PluginEntry>

const plugins = registry.getPlugins();
for (const plugin of plugins) {
  console.log(`Plugin: ${plugin.name}`);
}

PluginRegistry
├── pProviders    → Map<Token, ProviderDef>
├── pPlugins      → Map<Token, PluginRegistry>  (nested plugins)
├── pAdapters     → Map<Token, AdapterRegistry>
├── pTools        → Map<Token, ToolRegistry>
├── pResources    → Map<Token, ResourceRegistry>
├── pPrompts      → Map<Token, PromptRegistry>
└── pSkills       → Map<Token, SkillRegistry>

@FrontMcp({
  name: 'my-server',
  plugins: [
    RememberPlugin,
    CachePlugin,
    MyCustomPlugin,
  ],
})
class MyServer { }

@Plugin({
  name: 'my-plugin',
  tools: [CustomTool],
  providers: [CustomProvider],
})
class MyCustomPlugin { }

@Plugin({
  name: 'audit-plugin',
  hooks: [
    {
      flow: 'tools:call-tool',
      stage: 'afterExecute',
      handler: async (ctx) => {
        await auditLog(ctx.toolName, ctx.result);
      },
    },
  ],
})
class AuditPlugin { }

// In plugin
declare module '@frontmcp/sdk' {
  interface ExecutionContextBase {
    readonly remember: RememberApi;
  }
}

export function installRememberContextExtension(): void {
  Object.defineProperty(ExecutionContextBase.prototype, 'remember', {
    get: function() {
      return this.get(RememberToken);
    },
  });
}

@Tool({ name: 'my_tool', inputSchema: {} })
class MyTool extends ToolContext {
  async execute() {
    // Plugin-provided context extension
    await this.remember.set('key', 'value');
  }
}

@Plugin({
  name: 'cache-plugin',
  providers: [
    {
      token: CacheToken,
      useFactory: () => new RedisCache(),
      scope: ProviderScope.SINGLETON,
    },
  ],
})
class CachePlugin { }