@anton.andrusenko/shopify-mcp-admin 0.8.0 → 1.0.1

package/README.md

@@ -1,6 +1,6 @@
 # @anton.andrusenko/shopify-mcp-admin
 
-> 🛍️ **MCP Server for Shopify Admin API** — Enable AI agents to manage Shopify stores with 79 powerful tools
+> 🛍️ **MCP Server for Shopify Admin API** — Enable AI agents to manage Shopify stores with 81 powerful tools
 
 [![npm version](https://badge.fury.io/js/@anton.andrusenko%2Fshopify-mcp-admin.svg)](https://www.npmjs.com/package/@anton.andrusenko/shopify-mcp-admin)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
@@ -11,7 +11,8 @@
 
 ## ✨ Features
 
-- 🛠️ **79 MCP Tools** — Complete store management: products, inventory, collections, pages, blogs, redirects, metafields, markets, locales & translations
+- 🛠️ **81 MCP Tools** — Complete store management: products, inventory, collections, pages, blogs, redirects, metafields, markets, locales & translations
+- 📦 **Modular Architecture** — 7 modules with lazy loading for optimal AI performance (see [Tool Modules](#-tool-modules))
 - 🤖 **AI-Optimized** — Tool descriptions and error messages designed for LLM comprehension
 - 🔌 **Dual Transport** — STDIO for Claude Desktop, HTTP for ChatGPT/OpenAI
 - ⚡ **Rate Limiting** — Automatic retry with exponential backoff for Shopify API limits
@@ -107,6 +108,8 @@ Tokens are automatically refreshed every 24 hours.
 | `PORT` | No | `3000` | HTTP server port (when `TRANSPORT=http`) |
 | `DEBUG` | No | — | Enable debug logging (`1` or `true`) |
 | `LOG_LEVEL` | No | `info` | Log level: `debug`, `info`, `warn`, `error` |
+| `SHOPIFY_MCP_LAZY_LOADING` | No | `true` | Enable modular lazy loading (set to `false` for all tools at startup) |
+| `SHOPIFY_MCP_ROLE` | No | — | Role preset for automatic module loading (see [Role Presets](#-role-presets)) |
 
 **⚡ Authentication:** Provide EITHER `SHOPIFY_ACCESS_TOKEN` (legacy) OR both `SHOPIFY_CLIENT_ID` and `SHOPIFY_CLIENT_SECRET` (Dev Dashboard).
 
@@ -248,9 +251,61 @@ Each tool can be converted to OpenAI function format:
 
 ---
 
+## 🎭 Role Presets
+
+Role presets automatically load appropriate tool modules at startup, optimizing the tool set for specific workflows and reducing AI context overhead.
+
+### Available Presets
+
+| Preset | Modules | Tools | Use Case |
+|--------|---------|-------|----------|
+| `inventory-manager` | core | 15 | Stock management and inventory operations |
+| `product-manager` | core, store-context, collections, product-extensions | 41 | Full product catalog management |
+| `content-manager` | core, content | 37 | Pages, blogs, and content marketing |
+| `seo-specialist` | core, collections, product-extensions, advanced-redirects | 38 | SEO optimization and URL management |
+| `international-manager` | core, store-context, international, collections | 46 | Multi-market and translation management |
+| `full-access` | All 7 modules | 81 | Full store administration |
+
+### Using Role Presets
+
+Set the `SHOPIFY_MCP_ROLE` environment variable:
+
+```bash
+export SHOPIFY_MCP_ROLE=product-manager
+npx @anton.andrusenko/shopify-mcp-admin
+```
+
+Or in Claude Desktop config:
+
+```json
+{
+  "mcpServers": {
+    "shopify": {
+      "command": "npx",
+      "args": ["-y", "@anton.andrusenko/shopify-mcp-admin"],
+      "env": {
+        "SHOPIFY_STORE_URL": "your-store.myshopify.com",
+        "SHOPIFY_ACCESS_TOKEN": "shpat_xxxxx",
+        "SHOPIFY_MCP_ROLE": "product-manager"
+      }
+    }
+  }
+}
+```
+
+### Module Discovery
+
+If no role is set, the server starts with core tools only (15 tools). AI agents can discover and load additional modules dynamically:
+
+1. **Discover modules**: Use `list-modules` to see available modules
+2. **Load modules**: Use `load-module` with the module name to enable tools
+3. **Suggestions**: Tool responses include suggestions for relevant modules to load
+
+---
+
 ## 🛠️ Available Tools
 
-@anton.andrusenko/shopify-mcp-admin provides **79 tools** organized into 16 categories:
+@anton.andrusenko/shopify-mcp-admin provides **81 tools** (79 domain tools + 2 meta-tools) organized into 16 categories:
 
 <details>
 <summary><strong>🏪 Store Info (9 tools)</strong></summary>
@@ -499,6 +554,289 @@ Each tool can be converted to OpenAI function format:
 
 ---
 
+## 📦 Tool Modules
+
+shopify-mcp-admin uses a modular architecture to optimize AI agent performance. Instead of loading all 81 tools at startup (which can degrade AI performance by up to 85%), tools are organized into 7 modules that can be loaded on demand.
+
+### How Module Loading Works
+
+1. **At startup:** Only the **Core Module** (15 tools) is loaded by default
+2. **Discovery:** AI agents use `list-modules` to see available modules
+3. **Loading:** AI agents use `load-module` to enable additional tools
+4. **Suggestions:** Tool responses include hints about which modules to load next
+
+### Module Dependency Diagram
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                         CORE MODULE                              │
+│            (Always Loaded - 15 tools)                           │
+│   Products (7) • Inventory (4) • Store Info (2) • Meta (2)      │
+└─────────────────────────────────────────────────────────────────┘
+        │
+        ├──────────────────────────────────────────────────────────┐
+        │                                                          │
+        ▼                                                          ▼
+┌───────────────────┐  ┌───────────────────┐  ┌───────────────────┐
+│  STORE CONTEXT    │  │   COLLECTIONS     │  │     CONTENT       │
+│     (7 tools)     │  │    (10 tools)     │  │    (22 tools)     │
+│   No deps         │  │   No deps         │  │    No deps        │
+└───────────────────┘  └───────────────────┘  └───────────────────┘
+                               │
+        ├──────────────────────┼──────────────────────────────────┐
+        │                      │                                  │
+        ▼                      ▼                                  ▼
+┌───────────────────┐  ┌───────────────────┐  ┌───────────────────┐
+│   INTERNATIONAL   │  │ PRODUCT EXTENSIONS│  │ ADVANCED REDIRECTS│
+│    (14 tools)     │  │     (9 tools)     │  │     (4 tools)     │
+│    No deps        │  │    No deps        │  │ Deps: product-ext │
+└───────────────────┘  └───────────────────┘  └───────────────────┘
+```
+
+### Module: Core (15 tools) — Always Loaded
+
+**Description:** Essential product and inventory management tools that form the foundation for most Shopify operations. Always loaded at startup.
+
+**Dependencies:** None
+
+**Tools:**
+
+| Category | Tools |
+|----------|-------|
+| Products (7) | `create-product`, `get-product`, `update-product`, `delete-product`, `list-products`, `update-product-variant`, `add-product-image` |
+| Inventory (4) | `get-inventory`, `update-inventory`, `list-low-inventory`, `get-bulk-inventory` |
+| Store Info (2) | `get-store-info`, `get-store-limits` |
+| Meta Tools (2) | `list-modules`, `load-module` |
+
+**Use Case:** Basic product catalog management, inventory tracking, and store information queries.
+
+---
+
+### Module: Store Context (7 tools)
+
+**Description:** Extended store configuration and context tools from Epic 11. Provides deep insights into store configuration including features, currencies, shipping, and more.
+
+**Dependencies:** None
+
+**Tools:**
+- `get-store-features` — Feature flags (gift cards, reports, storefront, bundles)
+- `get-store-currencies` — Multi-currency configuration
+- `get-store-shipping` — Shipping countries and zones
+- `get-store-domain` — Primary domain configuration
+- `get-store-taxes` — Tax configuration
+- `get-store-policies` — Legal policies (privacy, terms, refund)
+- `get-store-alerts` — Admin alerts and setup requirements
+
+**Use Case:** Understanding store capabilities before operations, multi-currency setup, tax configuration.
+
+**Load Command:** `load-module(module: "store-context")`
+
+---
+
+### Module: Collections (10 tools)
+
+**Description:** Product collection management for organizing products and navigation. Includes CRUD operations and metafields.
+
+**Dependencies:** None
+
+**Tools:**
+
+| Category | Tools |
+|----------|-------|
+| CRUD (7) | `list-collections`, `get-collection`, `create-collection`, `update-collection`, `delete-collection`, `add-products-to-collection`, `remove-products-from-collection` |
+| Metafields (3) | `get-collection-metafields`, `set-collection-metafields`, `delete-collection-metafields` |
+
+**Use Case:** Organizing products into collections, SEO optimization, storefront navigation.
+
+**Load Command:** `load-module(module: "collections")`
+
+---
+
+### Module: Product Extensions (9 tools)
+
+**Description:** Extended product management including metafields, advanced image operations, and URL redirects for SEO.
+
+**Dependencies:** None
+
+**Tools:**
+
+| Category | Tools |
+|----------|-------|
+| Metafields (3) | `get-product-metafields`, `set-product-metafields`, `delete-product-metafields` |
+| Images (3) | `update-product-image`, `delete-product-image`, `reorder-product-images` |
+| Redirects (3) | `create-redirect`, `list-redirects`, `delete-redirect` |
+
+**Use Case:** Adding custom metadata to products, SEO image alt text, URL redirects when changing product handles.
+
+**Load Command:** `load-module(module: "product-extensions")`
+
+---
+
+### Module: Content (22 tools)
+
+**Description:** Content management for pages, blogs, and articles. Complete CRUD operations plus metafields for content marketing and SEO.
+
+**Dependencies:** None
+
+**Tools:**
+
+| Category | Tools |
+|----------|-------|
+| Pages (8) | `list-pages`, `get-page`, `create-page`, `update-page`, `delete-page`, `get-page-metafields`, `set-page-metafields`, `delete-page-metafields` |
+| Blogs (7) | `list-blogs`, `create-blog`, `update-blog`, `delete-blog`, `get-blog-metafields`, `set-blog-metafields`, `delete-blog-metafields` |
+| Articles (7) | `list-articles`, `create-article`, `update-article`, `delete-article`, `get-article-metafields`, `set-article-metafields`, `delete-article-metafields` |
+
+**Use Case:** Content marketing, blog management, static pages (About, Contact, FAQ).
+
+**Load Command:** `load-module(module: "content")`
+
+---
+
+### Module: International (14 tools)
+
+**Description:** International commerce and localization tools. Markets, web presence, and shop locale translations for multi-region stores.
+
+**Dependencies:** None
+
+**Tools:**
+
+| Category | Tools |
+|----------|-------|
+| Markets (5) | `list-markets`, `get-market`, `create-market`, `update-market`, `delete-market` |
+| Web Presence (4) | `list-web-presences`, `create-web-presence`, `update-web-presence`, `delete-web-presence` |
+| Translations (5) | `list-shop-locales`, `enable-shop-locale`, `disable-shop-locale`, `register-translations`, `remove-translations` |
+
+**Use Case:** Multi-region selling, localized storefronts, translation management.
+
+**Load Command:** `load-module(module: "international")`
+
+---
+
+### Module: Advanced Redirects (4 tools)
+
+**Description:** Bulk URL redirect operations for large-scale SEO management. Import and mass-delete capabilities.
+
+**Dependencies:** `product-extensions` (auto-loaded when you load this module)
+
+**Tools:**
+- `bulk-delete-redirects` — Delete multiple redirects by ID
+- `bulk-delete-redirects-by-search` — Delete redirects matching a search query
+- `import-redirects` — Import redirects from CSV URL
+- `submit-redirect-import` — Submit a redirect import job for processing
+
+**Use Case:** Site migrations, bulk URL updates, SEO cleanup operations.
+
+**Load Command:** `load-module(module: "advanced-redirects")`
+
+> **Note:** Loading this module automatically loads `product-extensions` (9 tools) as a dependency.
+
+---
+
+### Choosing the Right Module
+
+| If you need to... | Load these modules |
+|-------------------|-------------------|
+| Manage basic products and inventory | Core only (default) |
+| Work with collections and organize products | `collections` |
+| Add product metafields or manage images | `product-extensions` |
+| Manage blog posts and pages | `content` |
+| Set up international markets | `international` |
+| Bulk manage URL redirects | `advanced-redirects` |
+| Full store administration | Use `full-access` role preset |
+
+---
+
+## 🔄 Upgrading from Previous Versions
+
+### What's New in v0.8.0+: Modular Tool Loading
+
+Starting with v0.8.0, shopify-mcp-admin uses **lazy loading** to optimize AI agent performance. Research shows that presenting more than 30 tools to an AI agent can degrade performance by up to 85%.
+
+**Default Behavior (Lazy Loading Enabled):**
+- Only 15 core tools are loaded at startup
+- Additional tools are loaded on-demand via `load-module`
+- AI agents discover available modules using `list-modules`
+- Token usage reduced by up to 81% compared to loading all tools
+
+### Breaking Changes
+
+| Previous Behavior | New Behavior (v0.8.0+) |
+|-------------------|------------------------|
+| All 79+ tools loaded at startup | 15 core tools loaded at startup |
+| No module concept | 7 modules with lazy loading |
+| N/A | `list-modules` and `load-module` meta-tools added |
+
+### Legacy Mode: Restore Previous Behavior
+
+If you prefer all tools loaded at startup (not recommended for optimal AI performance):
+
+```bash
+# Option 1: Environment variable
+export SHOPIFY_MCP_LAZY_LOADING=false
+
+# Option 2: In Claude Desktop config
+{
+  "mcpServers": {
+    "shopify": {
+      "command": "npx",
+      "args": ["-y", "@anton.andrusenko/shopify-mcp-admin"],
+      "env": {
+        "SHOPIFY_STORE_URL": "your-store.myshopify.com",
+        "SHOPIFY_ACCESS_TOKEN": "shpat_xxxxx",
+        "SHOPIFY_MCP_LAZY_LOADING": "false"
+      }
+    }
+  }
+}
+```
+
+### Migration Steps
+
+1. **Review your use case** — Do you need all 81 tools? Most workflows only need a subset.
+
+2. **Choose a role preset** (recommended) — Set `SHOPIFY_MCP_ROLE` for pre-configured modules:
+   ```bash
+   export SHOPIFY_MCP_ROLE=product-manager
+   ```
+
+3. **Or use on-demand loading** — Let AI agents discover and load modules as needed:
+   - AI uses `list-modules` to see available modules
+   - AI uses `load-module` with module name to enable tools
+   - Tool responses suggest relevant modules automatically
+
+4. **Or disable lazy loading** — Set `SHOPIFY_MCP_LAZY_LOADING=false` for legacy behavior
+
+### When to Use Each Mode
+
+| Mode | Tools | Best For |
+|------|-------|----------|
+| **Lazy Loading (default)** | 15 at startup | New projects, optimal AI performance |
+| **Role Preset** | 15-81 based on role | Specific workflows (e.g., content manager) |
+| **Legacy Mode** | All 81 | Backward compatibility, full store admin |
+
+### Performance Comparison
+
+| Mode | Tools at Startup | Est. Token Usage | AI Performance |
+|------|------------------|------------------|----------------|
+| Lazy Loading (default) | 15 | ~4,500 | ⭐⭐⭐ Optimal |
+| inventory-manager | 15 | ~4,500 | ⭐⭐⭐ Optimal |
+| content-manager | 37 | ~11,100 | ⭐⭐ Good |
+| product-manager | 41 | ~12,300 | ⭐⭐ Good |
+| international-manager | 46 | ~13,800 | ⭐⭐ Good |
+| full-access | 81 | ~24,000 | ⭐ May degrade |
+| Legacy Mode | 81 | ~24,000 | ⭐ May degrade |
+
+### Troubleshooting Module Loading
+
+| Issue | Solution |
+|-------|----------|
+| Tool not found after upgrade | Load the appropriate module: `load-module(module: "collections")` |
+| "Module not found" error | Use `list-modules` to see valid module names |
+| Want all tools at startup | Set `SHOPIFY_MCP_LAZY_LOADING=false` |
+| AI agent loading too many modules | Use a role preset instead of on-demand loading |
+
+---
+
 ## 🔧 Troubleshooting
 
 ### Common Errors
@@ -543,13 +881,14 @@ npm run inspect:config
 
 MCP Inspector opens a web UI at `http://localhost:6274` where you can:
 
-- 📋 Browse all 79 registered tools with schemas
+- 📋 Browse registered tools with schemas (15 core tools by default, up to 81 with modules)
+- 📦 Test module loading via `list-modules` and `load-module`
 - 📊 Access 9 MCP resources for store context
 - ▶️ Execute tools interactively and view results
 - 🔍 Inspect JSON-RPC protocol messages
 - 📊 Monitor server events in real-time
 
-> **Tip:** Use `npm run inspect:dev` during development for instant feedback without rebuilding.
+> **Tip:** Copy `mcp-inspector.example.json` to `mcp-inspector.json` for pre-configured role presets like `product-manager` or `full-access`.
 
 ---
 

package/dist/index.js

@@ -25,7 +25,17 @@ var configSchema = z.object({
   TRANSPORT: z.enum(["stdio", "http"]).default("stdio"),
   // Store info cache TTL (milliseconds)
   // Default: 5 minutes (300000ms) - configurable for performance tuning
-  STORE_INFO_CACHE_TTL_MS: z.string().optional().default("300000").transform(Number).describe("Cache TTL for store info in milliseconds (default: 5 minutes)")
+  STORE_INFO_CACHE_TTL_MS: z.string().optional().default("300000").transform(Number).describe("Cache TTL for store info in milliseconds (default: 5 minutes)"),
+  // Lazy loading configuration (Epic 12)
+  // Default: true - enables module-based lazy loading for optimal AI performance
+  // Set to 'false' or '0' to load all tools at startup (legacy mode)
+  SHOPIFY_MCP_LAZY_LOADING: z.string().optional().default("true").transform((val) => val === "true" || val === "1").describe("Enable lazy loading of tools via modules (default: true)"),
+  // Role preset configuration (Story 12.3: Progressive Loading)
+  // Automatically loads appropriate modules at startup based on role
+  // Valid roles: inventory-manager, product-manager, content-manager,
+  //              seo-specialist, international-manager, full-access
+  // When not set, only core module is loaded (requires manual module loading)
+  SHOPIFY_MCP_ROLE: z.string().optional().describe("Role preset for automatic module loading at startup")
 }).refine(
   (data) => {
     const hasLegacyAuth = !!data.SHOPIFY_ACCESS_TOKEN;
@@ -73,6 +83,12 @@ function isDebugEnabled(debugValue) {
   const normalized = debugValue.toLowerCase().trim();
   return normalized === "1" || normalized === "true";
 }
+function isLazyLoadingEnabled(config) {
+  return config.SHOPIFY_MCP_LAZY_LOADING;
+}
+function getConfiguredRole(config) {
+  return config.SHOPIFY_MCP_ROLE;
+}
 
 // src/config/index.ts
 var _config = null;
@@ -1310,14 +1326,45 @@ var packageJson = require2("../package.json");
 var SERVER_NAME = "shopify-mcp-admin";
 var SERVER_INSTRUCTIONS = `This MCP server provides access to a Shopify store's Admin API.
 
-KEY CONCEPTS:
-- Products contain variants; each variant has its own price, SKU, and inventory
-- Inventory is tracked per variant AND per location (multi-location stores)
-- Metafields store custom data using namespace/key pairs
-- Collections organize products for navigation and SEO
-- All IDs use Shopify GID format: "gid://shopify/Product/123"
+## TOOL MODULES (Modular Architecture)
+
+Tools are organized into modules for optimal AI performance. Start with core tools and load additional modules as needed.
+
+**Discovery & Loading:**
+- Use "list-modules" to see all available modules and their loading status
+- Use "load-module" with module name to enable additional tools
+- Tool responses may include suggestions for relevant modules to load
+
+**Available Modules:**
+| Module | Description | Tools |
+|--------|-------------|-------|
+| core | Products, inventory, store info (always loaded) | 15 |
+| store-context | Extended store configuration (features, currencies, shipping) | 7 |
+| collections | Collection management and metafields | 10 |
+| product-extensions | Product metafields, images, and URL redirects | 9 |
+| content | Pages, blogs, and articles management | 22 |
+| international | Markets, web presence, and translations | 14 |
+| advanced-redirects | Bulk redirect operations | 4 |
+
+**Role Presets (SHOPIFY_MCP_ROLE):**
+Pre-configured module sets for common workflows:
+- inventory-manager: Core only (15 tools) - stock management
+- product-manager: Core + store-context + collections + product-extensions (41 tools)
+- content-manager: Core + content (37 tools) - pages and blogs
+- seo-specialist: Core + collections + product-extensions + advanced-redirects (38 tools)
+- international-manager: Core + store-context + international + collections (46 tools)
+- full-access: All modules (81 tools) - full store administration
+
+## KEY CONCEPTS
+
+- **Products & Variants**: Products contain variants; each variant has its own price, SKU, and inventory
+- **Multi-location Inventory**: Inventory is tracked per variant AND per location
+- **Metafields**: Store custom data using namespace/key pairs on products, collections, pages, blogs, and articles
+- **Collections**: Organize products for navigation and SEO
+- **GID Format**: All IDs use Shopify GID format: "gid://shopify/Product/123"
+
+## RESOURCE TYPES & GID FORMATS
 
-RESOURCE TYPES & GID FORMATS:
 - Products: gid://shopify/Product/{id}
 - Variants: gid://shopify/ProductVariant/{id}
 - Collections: gid://shopify/Collection/{id}
@@ -1329,21 +1376,25 @@ RESOURCE TYPES & GID FORMATS:
 - InventoryItems: gid://shopify/InventoryItem/{id}
 - Locations: gid://shopify/Location/{id}
 
-BEST PRACTICES:
-- Always verify product/variant IDs using get-product before updates
-- Use list-low-inventory to proactively identify stock issues
-- When updating SEO, consider updating URL redirects
-- For bulk operations, prefer bulk tools when available
-- Use metafields to store custom SEO data (JSON-LD, Open Graph)
+## BEST PRACTICES
+
+- **Verify before modifying**: Use get-product to verify IDs before updates
+- **Proactive inventory**: Use list-low-inventory to identify stock issues
+- **SEO redirects**: When updating product handles, consider creating URL redirects
+- **Bulk operations**: Use bulk tools (get-bulk-inventory, bulk-delete-redirects) when available
+- **Metafields for SEO**: Store custom SEO data (JSON-LD, Open Graph) in metafields
+
+## RATE LIMITS
 
-RATE LIMITS:
 - Shopify GraphQL has cost-based rate limiting (~50 points/sec)
 - Large queries may retry automatically with exponential backoff
 - Rate limit errors include helpful retry suggestions
 
-WORKFLOW HINTS:
+## WORKFLOW HINTS
+
 - Tool descriptions include **Prerequisites:** and **Follow-ups:** for multi-step operations
-- Check tool category and relationships for semantic grouping`;
+- Check tool category and relationships for semantic grouping
+- After successful operations, note any module suggestions in the response`;
 function getServerVersion() {
   return packageJson.version;
 }
@@ -1364,8 +1415,12 @@ function createServer() {
         logging: {}
         // Enable logging capability (AC-9.5.1.2)
       },
-      instructions: SERVER_INSTRUCTIONS
+      instructions: SERVER_INSTRUCTIONS,
       // Provide Shopify context to AI agents (AC-9.5.1.1)
+      // Epic 12: Notification debouncing for module loading (AC-12.1.6)
+      // When multiple tools are enabled in rapid succession (e.g., loading a module),
+      // coalesce into a single notifications/tools/list_changed notification
+      debouncedNotificationMethods: ["notifications/tools/list_changed"]
     }
   );
   return server;
@@ -3039,6 +3094,7 @@ function deriveDefaultAnnotations(name) {
   };
 }
 var registeredTools = /* @__PURE__ */ new Map();
+var toolEnabledState = /* @__PURE__ */ new Map();
 function validateToolName(name) {
   if (!name || name.trim() === "") {
     throw new Error("Tool name cannot be empty");
@@ -3097,7 +3153,7 @@ function wrapToolHandler(toolName, schema, handler) {
   };
 }
 function registerTool(definition, handler, options = {}) {
-  const { name, title, description, inputSchema: inputSchema80, annotations } = definition;
+  const { name, title, description, inputSchema: inputSchema82, annotations } = definition;
   try {
     if (!options.skipNameValidation) {
       validateToolName(name);
@@ -3105,8 +3161,8 @@ function registerTool(definition, handler, options = {}) {
     if (registeredTools.has(name)) {
       throw new Error(`Tool "${name}" is already registered. Tool names must be unique.`);
     }
-    const jsonSchema = convertZodToJsonSchema(inputSchema80);
-    const wrappedHandler = wrapToolHandler(name, inputSchema80, handler);
+    const jsonSchema = convertZodToJsonSchema(inputSchema82);
+    const wrappedHandler = wrapToolHandler(name, inputSchema82, handler);
     const finalAnnotations = {
       ...deriveDefaultAnnotations(name),
       ...annotations,
@@ -3118,7 +3174,7 @@ function registerTool(definition, handler, options = {}) {
       title,
       description,
       inputSchema: jsonSchema,
-      zodSchema: inputSchema80,
+      zodSchema: inputSchema82,
       handler: wrappedHandler,
       annotations: finalAnnotations
     };
@@ -3136,7 +3192,7 @@ function registerTool(definition, handler, options = {}) {
   }
 }
 function getRegisteredTools() {
-  return Array.from(registeredTools.values()).map((tool) => ({
+  return Array.from(registeredTools.values()).filter((tool) => isToolEnabled(tool.name)).map((tool) => ({
     name: tool.name,
     description: `${tool.title}: ${tool.description}`,
     inputSchema: tool.inputSchema,
@@ -3146,6 +3202,32 @@ function getRegisteredTools() {
 function getToolByName(name) {
   return registeredTools.get(name);
 }
+function getToolNames() {
+  return Array.from(registeredTools.keys());
+}
+function enableTool(name) {
+  const tool = registeredTools.get(name);
+  if (!tool) {
+    log.debug(`Cannot enable tool: ${name} not found`);
+    return false;
+  }
+  toolEnabledState.set(name, true);
+  log.debug(`Tool enabled: ${name}`);
+  return true;
+}
+function disableTool(name) {
+  const tool = registeredTools.get(name);
+  if (!tool) {
+    log.debug(`Cannot disable tool: ${name} not found`);
+    return false;
+  }
+  toolEnabledState.set(name, false);
+  log.debug(`Tool disabled: ${name}`);
+  return true;
+}
+function isToolEnabled(name) {
+  return toolEnabledState.get(name) ?? true;
+}
 function createHandlerWithContext(contextAwareHandler) {
   return async (params) => {
     const client = await getShopifyClient();
@@ -13558,6 +13640,549 @@ function registerGetStoreTaxesTool() {
   );
 }
 
+// src/tools/list-modules.ts
+import { z as z83 } from "zod";
+
+// src/tools/modules/registry.ts
+var CORE_MODULE = {
+  name: "core",
+  description: "Essential product and inventory management tools. Includes product CRUD, variants, basic images, inventory operations, and store info. Always loaded at startup.",
+  alwaysLoaded: true,
+  dependencies: [],
+  tools: [
+    // Products (7)
+    "create-product",
+    "get-product",
+    "update-product",
+    "delete-product",
+    "list-products",
+    "update-product-variant",
+    "add-product-image",
+    // Inventory (4)
+    "get-inventory",
+    "update-inventory",
+    "list-low-inventory",
+    "get-bulk-inventory",
+    // Store Info (2)
+    "get-store-info",
+    "get-store-limits",
+    // Meta Tools (2) - Added by this story
+    "list-modules",
+    "load-module"
+  ]
+};
+var STORE_CONTEXT_MODULE = {
+  name: "store-context",
+  description: "Extended store configuration and context tools. Includes features, currencies, shipping countries, domain, taxes, policies, and alerts. Use for comprehensive store insights.",
+  alwaysLoaded: false,
+  dependencies: [],
+  tools: [
+    "get-store-features",
+    "get-store-currencies",
+    "get-store-shipping",
+    "get-store-domain",
+    "get-store-taxes",
+    "get-store-policies",
+    "get-store-alerts"
+  ]
+};
+var COLLECTIONS_MODULE = {
+  name: "collections",
+  description: "Product collection management tools. Includes collection CRUD, adding/removing products, and collection metafields. Use for organizing products and SEO.",
+  alwaysLoaded: false,
+  dependencies: [],
+  tools: [
+    // CRUD (7)
+    "list-collections",
+    "get-collection",
+    "create-collection",
+    "update-collection",
+    "delete-collection",
+    "add-products-to-collection",
+    "remove-products-from-collection",
+    // Metafields (3)
+    "get-collection-metafields",
+    "set-collection-metafields",
+    "delete-collection-metafields"
+  ]
+};
+var PRODUCT_EXTENSIONS_MODULE = {
+  name: "product-extensions",
+  description: "Extended product management tools. Includes product metafields, advanced image operations (update, delete, reorder), and URL redirects for SEO.",
+  alwaysLoaded: false,
+  dependencies: [],
+  tools: [
+    // Metafields (3)
+    "get-product-metafields",
+    "set-product-metafields",
+    "delete-product-metafields",
+    // Images (3)
+    "update-product-image",
+    "delete-product-image",
+    "reorder-product-images",
+    // Redirects (3)
+    "create-redirect",
+    "list-redirects",
+    "delete-redirect"
+  ]
+};
+var CONTENT_MODULE = {
+  name: "content",
+  description: "Content management tools for pages, blogs, and articles. Includes CRUD operations and metafields for all content types. Use for content marketing and SEO.",
+  alwaysLoaded: false,
+  dependencies: [],
+  tools: [
+    // Pages (8)
+    "list-pages",
+    "get-page",
+    "create-page",
+    "update-page",
+    "delete-page",
+    "get-page-metafields",
+    "set-page-metafields",
+    "delete-page-metafields",
+    // Blogs (7)
+    "list-blogs",
+    "create-blog",
+    "update-blog",
+    "delete-blog",
+    "get-blog-metafields",
+    "set-blog-metafields",
+    "delete-blog-metafields",
+    // Articles (7)
+    "list-articles",
+    "create-article",
+    "update-article",
+    "delete-article",
+    "get-article-metafields",
+    "set-article-metafields",
+    "delete-article-metafields"
+  ]
+};
+var INTERNATIONAL_MODULE = {
+  name: "international",
+  description: "International commerce and localization tools. Includes markets management, web presence configuration, and shop locale translations. Use for multi-region and multi-language stores.",
+  alwaysLoaded: false,
+  dependencies: [],
+  tools: [
+    // Markets (5)
+    "list-markets",
+    "get-market",
+    "create-market",
+    "update-market",
+    "delete-market",
+    // Web Presence (4)
+    "list-web-presences",
+    "create-web-presence",
+    "update-web-presence",
+    "delete-web-presence",
+    // Translations (5)
+    "list-shop-locales",
+    "enable-shop-locale",
+    "disable-shop-locale",
+    "register-translations",
+    "remove-translations"
+  ]
+};
+var ADVANCED_REDIRECTS_MODULE = {
+  name: "advanced-redirects",
+  description: "Bulk URL redirect operations for large-scale SEO management. Includes bulk delete, delete by search, and import capabilities. Requires product-extensions module.",
+  alwaysLoaded: false,
+  dependencies: ["product-extensions"],
+  tools: [
+    "bulk-delete-redirects",
+    "bulk-delete-redirects-by-search",
+    "import-redirects",
+    "submit-redirect-import"
+  ]
+};
+var MODULE_DEFINITIONS = [
+  CORE_MODULE,
+  STORE_CONTEXT_MODULE,
+  COLLECTIONS_MODULE,
+  PRODUCT_EXTENSIONS_MODULE,
+  CONTENT_MODULE,
+  INTERNATIONAL_MODULE,
+  ADVANCED_REDIRECTS_MODULE
+];
+var registry = null;
+function initializeRegistry() {
+  const modules = /* @__PURE__ */ new Map();
+  const loadedModules = /* @__PURE__ */ new Set();
+  const toolModuleMap = /* @__PURE__ */ new Map();
+  for (const module of MODULE_DEFINITIONS) {
+    modules.set(module.name, module);
+    if (module.alwaysLoaded) {
+      loadedModules.add(module.name);
+    }
+    for (const toolName of module.tools) {
+      toolModuleMap.set(toolName, module.name);
+    }
+  }
+  registry = {
+    modules,
+    loadedModules,
+    toolModuleMap
+  };
+  log.debug(
+    `Module registry initialized: ${modules.size} modules, ${toolModuleMap.size} tools mapped`
+  );
+  return registry;
+}
+function getRegistry() {
+  if (!registry) {
+    return initializeRegistry();
+  }
+  return registry;
+}
+function getModule(name) {
+  return getRegistry().modules.get(name);
+}
+function isModuleLoaded(name) {
+  return getRegistry().loadedModules.has(name);
+}
+function getModuleForTool(toolName) {
+  return getRegistry().toolModuleMap.get(toolName);
+}
+function getLoadedModules() {
+  return Array.from(getRegistry().loadedModules);
+}
+function markModuleLoaded(name) {
+  getRegistry().loadedModules.add(name);
+  log.debug(`Module marked as loaded: ${name}`);
+}
+function getToolsForModule(moduleName) {
+  const module = getModule(moduleName);
+  return module ? module.tools : [];
+}
+
+// src/tools/modules/loading.ts
+async function loadModule(moduleName) {
+  log.debug(`Loading module: ${moduleName}`);
+  const module = getModule(moduleName);
+  if (!module) {
+    const availableModules = Array.from(getRegistry().modules.keys()).join(", ");
+    throw new ToolError(
+      `Module '${moduleName}' not found. Available modules: ${availableModules}`,
+      `Use list-modules to see available modules. Valid options: ${availableModules}`
+    );
+  }
+  if (isModuleLoaded(moduleName)) {
+    log.debug(`Module already loaded: ${moduleName}`);
+    return {
+      success: true,
+      moduleName,
+      toolsLoaded: 0,
+      tools: [],
+      dependenciesLoaded: []
+    };
+  }
+  const dependenciesLoaded = [];
+  const allLoadedTools = [];
+  for (const depName of module.dependencies) {
+    if (!isModuleLoaded(depName)) {
+      log.debug(`Loading dependency: ${depName} for ${moduleName}`);
+      const depResult = await loadModule(depName);
+      if (depResult.success && depResult.toolsLoaded > 0) {
+        dependenciesLoaded.push(depName);
+        allLoadedTools.push(...depResult.tools);
+        if (depResult.dependenciesLoaded.length > 0) {
+          dependenciesLoaded.push(...depResult.dependenciesLoaded);
+        }
+      }
+    }
+  }
+  markModuleLoaded(moduleName);
+  for (const toolName of module.tools) {
+    enableTool(toolName);
+  }
+  const result = {
+    success: true,
+    moduleName,
+    toolsLoaded: module.tools.length,
+    tools: [...module.tools],
+    dependenciesLoaded
+  };
+  log.debug(
+    `Module loaded: ${moduleName} (${result.toolsLoaded} tools, ${dependenciesLoaded.length} dependencies)`
+  );
+  return result;
+}
+async function loadModules(moduleNames) {
+  const results = [];
+  for (const moduleName of moduleNames) {
+    try {
+      const result = await loadModule(moduleName);
+      results.push(result);
+    } catch (error) {
+      results.push({
+        success: false,
+        moduleName,
+        toolsLoaded: 0,
+        tools: [],
+        dependenciesLoaded: [],
+        error: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  }
+  return results;
+}
+function getModuleStatus() {
+  const registry2 = getRegistry();
+  const modules = Array.from(registry2.modules.values()).map((module) => ({
+    name: module.name,
+    description: module.description,
+    toolCount: module.tools.length,
+    loaded: registry2.loadedModules.has(module.name),
+    dependencies: module.dependencies,
+    tools: module.tools
+  }));
+  let totalTools = 0;
+  let loadedTools = 0;
+  for (const module of modules) {
+    totalTools += module.toolCount;
+    if (module.loaded) {
+      loadedTools += module.toolCount;
+    }
+  }
+  return {
+    modules,
+    summary: {
+      totalModules: modules.length,
+      loadedModules: getLoadedModules().length,
+      totalTools,
+      loadedTools
+    }
+  };
+}
+
+// src/tools/modules/types.ts
+import { z as z82 } from "zod";
+var ToolModuleSchema = z82.object({
+  /** Unique module identifier (kebab-case) */
+  name: z82.string().regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, {
+    message: "Module name must be kebab-case"
+  }),
+  /** Human-readable description for AI discovery */
+  description: z82.string().min(10, {
+    message: "Description must be at least 10 characters"
+  }),
+  /** Whether this module is loaded at server startup */
+  alwaysLoaded: z82.boolean().default(false),
+  /** Module names that must be loaded before this module */
+  dependencies: z82.array(z82.string()).default([]),
+  /** Tool names belonging to this module */
+  tools: z82.array(z82.string())
+});
+var LOADABLE_MODULE_NAMES = [
+  "store-context",
+  "collections",
+  "product-extensions",
+  "content",
+  "international",
+  "advanced-redirects"
+];
+var ALL_MODULE_NAMES = ["core", ...LOADABLE_MODULE_NAMES];
+var ModuleInfoSchema = z82.object({
+  name: z82.string(),
+  description: z82.string(),
+  toolCount: z82.number().int().nonnegative(),
+  loaded: z82.boolean(),
+  dependencies: z82.array(z82.string()),
+  tools: z82.array(z82.string())
+});
+var ModuleSummarySchema = z82.object({
+  totalModules: z82.number().int().nonnegative(),
+  loadedModules: z82.number().int().nonnegative(),
+  totalTools: z82.number().int().nonnegative(),
+  loadedTools: z82.number().int().nonnegative()
+});
+var ListModulesResponseSchema = z82.object({
+  modules: z82.array(ModuleInfoSchema),
+  summary: ModuleSummarySchema
+});
+var ModuleLoadResultSchema = z82.object({
+  success: z82.boolean(),
+  moduleName: z82.string(),
+  toolsLoaded: z82.number().int().nonnegative(),
+  tools: z82.array(z82.string()),
+  dependenciesLoaded: z82.array(z82.string()),
+  error: z82.string().optional()
+});
+
+// src/tools/list-modules.ts
+var inputSchema80 = z83.object({});
+async function handleListModules(_context, _params) {
+  log.debug("Listing available modules");
+  const status = getModuleStatus();
+  log.debug(
+    `Modules listed: ${status.summary.loadedModules}/${status.summary.totalModules} loaded, ${status.summary.loadedTools}/${status.summary.totalTools} tools available`
+  );
+  return status;
+}
+function registerListModulesTool() {
+  registerContextAwareTool(
+    {
+      name: "list-modules",
+      title: "List Available Modules",
+      description: "List all available tool modules and their loading status. Shows module names, descriptions, tool counts, dependencies, and whether each module is loaded. Use this to discover which modules can be loaded to extend functionality. **Note:** The core module is always loaded with essential product and inventory tools.",
+      inputSchema: inputSchema80,
+      outputSchema: ListModulesResponseSchema,
+      category: "store",
+      relationships: {
+        relatedTools: ["load-module"],
+        followUps: ["load-module"]
+      },
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        // Does NOT call Shopify API - internal state only
+        openWorldHint: false
+      }
+    },
+    handleListModules
+  );
+}
+
+// src/tools/load-module.ts
+import { z as z84 } from "zod";
+var inputSchema81 = z84.object({
+  module: z84.enum(LOADABLE_MODULE_NAMES).describe(
+    "Name of the module to load. Options: store-context, collections, product-extensions, content, international, advanced-redirects"
+  )
+});
+async function handleLoadModule(_context, params) {
+  log.debug(`Loading module: ${params.module}`);
+  const result = await loadModule(params.module);
+  if (result.success) {
+    if (result.toolsLoaded > 0) {
+      log.debug(
+        `Module ${params.module} loaded: ${result.toolsLoaded} tools, ${result.dependenciesLoaded.length} dependencies`
+      );
+    } else {
+      log.debug(`Module ${params.module} was already loaded`);
+    }
+  }
+  return result;
+}
+function registerLoadModuleTool() {
+  registerContextAwareTool(
+    {
+      name: "load-module",
+      title: "Load Tool Module",
+      description: "Load a tool module to enable additional tools for a specific domain. Dependencies are automatically loaded. Use list-modules to see available modules. **Available modules:** store-context (store configuration), collections (product organization), product-extensions (metafields, images, redirects), content (pages, blogs, articles), international (markets, translations), advanced-redirects (bulk operations). **Note:** Once loaded, modules remain available for the session.",
+      inputSchema: inputSchema81,
+      outputSchema: ModuleLoadResultSchema,
+      category: "store",
+      relationships: {
+        prerequisites: ["list-modules"],
+        relatedTools: ["list-modules"]
+      },
+      annotations: {
+        // Not read-only: changes internal tool availability state
+        readOnlyHint: false,
+        destructiveHint: false,
+        // Idempotent: loading same module twice returns success
+        idempotentHint: true,
+        // Does NOT call Shopify API - internal state only
+        openWorldHint: false
+      }
+    },
+    handleLoadModule
+  );
+}
+
+// src/tools/modules/presets.ts
+import { z as z85 } from "zod";
+var RolePresetSchema = z85.object({
+  description: z85.string(),
+  modules: z85.array(z85.string())
+});
+var ROLE_PRESETS = {
+  "inventory-manager": {
+    description: "Stock management and inventory operations",
+    modules: ["core"]
+  },
+  "product-manager": {
+    description: "Full product catalog management",
+    modules: ["core", "store-context", "collections", "product-extensions"]
+  },
+  "content-manager": {
+    description: "Pages, blogs, and content marketing",
+    modules: ["core", "content"]
+  },
+  "seo-specialist": {
+    description: "SEO optimization and URL management",
+    modules: ["core", "collections", "product-extensions", "advanced-redirects"]
+  },
+  "international-manager": {
+    description: "Multi-market and translation management",
+    modules: ["core", "store-context", "international", "collections"]
+  },
+  "full-access": {
+    description: "All tools for store administrators",
+    modules: [
+      "core",
+      "store-context",
+      "collections",
+      "product-extensions",
+      "content",
+      "international",
+      "advanced-redirects"
+    ]
+  }
+};
+var VALID_ROLE_NAMES = Object.keys(ROLE_PRESETS);
+function isValidRoleName(name) {
+  return name in ROLE_PRESETS;
+}
+function getPresetModules(role) {
+  return [...ROLE_PRESETS[role].modules];
+}
+
+// src/tools/suggestions.ts
+var TOOL_SUGGESTIONS = {
+  // Product tools → suggest product-extensions and collections
+  "create-product": [
+    { name: "product-extensions", reason: "Add metafields, manage images" },
+    { name: "collections", reason: "Organize in collections" }
+  ],
+  "get-product": [{ name: "product-extensions", reason: "View metafields, images" }],
+  "update-product": [
+    { name: "product-extensions", reason: "Update metafields" },
+    { name: "collections", reason: "Manage collection membership" }
+  ],
+  "list-products": [{ name: "collections", reason: "Categorize and filter by collection" }],
+  "delete-product": [
+    { name: "product-extensions", reason: "Check redirects, clean up metafields" }
+  ],
+  "update-product-variant": [{ name: "product-extensions", reason: "Manage variant metafields" }],
+  "add-product-image": [{ name: "product-extensions", reason: "Reorder images, update alt text" }],
+  // Inventory tools → suggest store-context for location info
+  "get-inventory": [{ name: "store-context", reason: "Location information" }],
+  "update-inventory": [{ name: "store-context", reason: "Location details" }],
+  "list-low-inventory": [{ name: "store-context", reason: "Location context" }],
+  "get-bulk-inventory": [{ name: "store-context", reason: "Location information" }],
+  // Store info tools → suggest store-context for full configuration
+  "get-store-info": [{ name: "store-context", reason: "Full store configuration" }],
+  "get-store-limits": [{ name: "store-context", reason: "Additional store details" }]
+};
+function getSuggestionsForTool(toolName) {
+  const suggestions = TOOL_SUGGESTIONS[toolName];
+  if (!suggestions || suggestions.length === 0) {
+    return null;
+  }
+  const unloadedSuggestions = suggestions.filter((s) => !isModuleLoaded(s.name));
+  if (unloadedSuggestions.length === 0) {
+    return null;
+  }
+  return {
+    modules: unloadedSuggestions,
+    hint: "Use load-module to enable these tools"
+  };
+}
+
 // src/tools/index.ts
 function setupToolHandlers(server) {
   server.server.setRequestHandler(ListToolsRequestSchema, async () => {
@@ -13574,18 +14199,23 @@ function setupToolHandlers(server) {
     };
   });
   server.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { name, arguments: params } = request.params;
-    log.debug(`tools/call received: ${name}`);
+    const { name: rawName, arguments: params } = request.params;
+    log.debug(`tools/call received: ${rawName}`);
+    const nameParts = rawName.split(":");
+    const name = nameParts.length > 1 ? nameParts[nameParts.length - 1] : rawName;
+    if (name !== rawName) {
+      log.debug(`Stripped prefix from tool name: "${rawName}" -> "${name}"`);
+    }
     const tool = getToolByName(name);
     if (!tool) {
       const availableTools = getRegisteredTools();
       const toolList = availableTools.length > 0 ? `Available tools: ${availableTools.map((t) => t.name).join(", ")}` : "No tools are currently registered.";
-      log.warn(`Tool not found: ${name}`);
+      log.warn(`Tool not found: ${name}${name !== rawName ? ` (received as "${rawName}")` : ""}`);
       return {
         content: [
           {
             type: "text",
-            text: `Error: Tool "${name}" not found.
+            text: `Error: Tool "${name}" not found${name !== rawName ? ` (received as "${rawName}")` : ""}.
 
 Suggestion: Use tools/list to see available tools. ${toolList}`
           }
@@ -13593,8 +14223,42 @@ Suggestion: Use tools/list to see available tools. ${toolList}`
         isError: true
       };
     }
+    if (!isToolEnabled(name)) {
+      const moduleName = getModuleForTool(name);
+      const suggestion = moduleName ? `Load the '${moduleName}' module first: use load-module with module: "${moduleName}"` : "This tool is currently disabled. Use list-modules to see available modules.";
+      log.debug(`Tool "${name}" is disabled, suggesting module: ${moduleName || "unknown"}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Error: Tool "${name}" is not currently loaded.
+
+Suggestion: ${suggestion}`
+          }
+        ],
+        isError: true
+      };
+    }
     try {
       const response = await tool.handler(params ?? {});
+      const config = getConfig();
+      if (isLazyLoadingEnabled(config) && !response.isError) {
+        const suggestions = getSuggestionsForTool(name);
+        if (suggestions) {
+          const suggestionText = `
+---
+\u{1F4A1} **Related modules available:**
+${suggestions.modules.map((m) => `- **${m.name}**: ${m.reason}`).join("\n")}
+
+_${suggestions.hint}_`;
+          if (Array.isArray(response.content)) {
+            response.content.push({
+              type: "text",
+              text: suggestionText
+            });
+          }
+        }
+      }
       return response;
     } catch (error) {
       log.error(`Unexpected error in tool ${name}:`, error instanceof Error ? error : void 0);
@@ -13614,6 +14278,7 @@ Suggestion: Please try again or contact support if the issue persists.`
 }
 function registerAllTools(server) {
   setupToolHandlers(server);
+  initializeRegistry();
   registerAddProductImageTool();
   registerCreateProductTool();
   registerDeleteProductTool();
@@ -13693,8 +14358,69 @@ function registerAllTools(server) {
   registerGetStoreTaxesTool();
   registerGetStorePoliciesTool();
   registerGetStoreAlertsTool();
-  const toolCount = getRegisteredTools().length;
-  log.debug(`Tool registration complete: ${toolCount} tools registered`);
+  registerListModulesTool();
+  registerLoadModuleTool();
+  const totalToolCount = getToolNames().length;
+  const config = getConfig();
+  if (isLazyLoadingEnabled(config)) {
+    applyLazyLoading();
+    const roleResult = applyRolePreset(config);
+    const enabledCount = getRegisteredTools().length;
+    if (roleResult.applied) {
+      log.info(
+        `Role preset '${roleResult.role}' applied: ${enabledCount} tools active (${roleResult.modulesLoaded.length} modules loaded)`
+      );
+    } else {
+      log.info(
+        `Lazy loading enabled: ${enabledCount} core tools active, ${totalToolCount - enabledCount} tools available via modules`
+      );
+    }
+  } else {
+    log.info(`Lazy loading disabled (legacy mode): ${totalToolCount} tools registered`);
+  }
+}
+function applyLazyLoading() {
+  const coreTools = new Set(getToolsForModule("core"));
+  const allToolNames = getToolNames();
+  let disabledCount = 0;
+  for (const toolName of allToolNames) {
+    if (!coreTools.has(toolName)) {
+      disableTool(toolName);
+      disabledCount++;
+    }
+  }
+  log.debug(`Lazy loading: disabled ${disabledCount} non-core tools`);
+}
+function applyRolePreset(config) {
+  const role = getConfiguredRole(config);
+  if (!role) {
+    return { applied: false, modulesLoaded: [] };
+  }
+  if (!isValidRoleName(role)) {
+    log.warn(
+      `Invalid role preset '${role}'. Valid roles: inventory-manager, product-manager, content-manager, seo-specialist, international-manager, full-access`
+    );
+    return {
+      applied: false,
+      modulesLoaded: [],
+      warning: `Invalid role '${role}' - continuing with core tools only`
+    };
+  }
+  const presetModules = getPresetModules(role);
+  const modulesToLoad = presetModules.filter((m) => m !== "core");
+  if (modulesToLoad.length === 0) {
+    log.debug(`Role preset '${role}' requires only core module`);
+    return { applied: true, role, modulesLoaded: [] };
+  }
+  loadModules(modulesToLoad).then((results) => {
+    const successful = results.filter((r) => r.success).map((r) => r.moduleName);
+    const failed = results.filter((r) => !r.success).map((r) => r.moduleName);
+    if (failed.length > 0) {
+      log.warn(`Role preset '${role}': failed to load modules: ${failed.join(", ")}`);
+    }
+    log.debug(`Role preset '${role}': loaded modules: ${successful.join(", ")}`);
+  });
+  return { applied: true, role, modulesLoaded: modulesToLoad };
 }
 
 // src/transports/stdio.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anton.andrusenko/shopify-mcp-admin",
-  "version": "0.8.0",
+  "version": "1.0.1",
   "description": "MCP server for Shopify Admin API - enables AI agents to manage Shopify stores with 71 tools for products, inventory, collections, content, SEO, metafields, markets & translations",
   "type": "module",
   "main": "./dist/index.js",