@anton.andrusenko/shopify-mcp-admin 1.0.1 → 1.1.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 81 powerful tools
+> 🛍️ **MCP Server for Shopify Admin API** — Enable AI agents to manage Shopify stores with 79 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,8 +11,8 @@
 
 ## ✨ Features
 
-- 🛠️ **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))
+- 🛠️ **79 MCP Tools** — Complete store management: products, inventory, collections, pages, blogs, redirects, metafields, markets, locales & translations
+- 📦 **Modular Architecture** — 7 modules with optional 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
@@ -108,7 +108,7 @@ 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_LAZY_LOADING` | No | `false` | Enable modular lazy loading (set to `true` for on-demand module loading) |
 | `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).
@@ -264,7 +264,7 @@ Role presets automatically load appropriate tool modules at startup, optimizing
 | `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 |
+| `full-access` | All 7 modules | 81 | Full store administration (includes meta-tools) |
 
 ### Using Role Presets
 
@@ -293,19 +293,21 @@ Or in Claude Desktop config:
 }
 ```
 
-### Module Discovery
+### Module Discovery (Lazy Loading Mode)
 
-If no role is set, the server starts with core tools only (15 tools). AI agents can discover and load additional modules dynamically:
+When lazy loading is enabled (`SHOPIFY_MCP_LAZY_LOADING=true`) and 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
 
+> **Note:** When lazy loading is disabled (default), all 79 tools are available immediately and module discovery is not needed.
+
 ---
 
 ## 🛠️ Available Tools
 
-@anton.andrusenko/shopify-mcp-admin provides **81 tools** (79 domain tools + 2 meta-tools) organized into 16 categories:
+@anton.andrusenko/shopify-mcp-admin provides **79 domain tools** organized into 16 categories (plus 2 meta-tools when lazy loading is enabled):
 
 <details>
 <summary><strong>🏪 Store Info (9 tools)</strong></summary>
@@ -556,13 +558,15 @@ If no role is set, the server starts with core tools only (15 tools). AI agents
 
 ## 📦 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.
+shopify-mcp-admin uses a modular architecture to optimize AI agent performance. Instead of loading all 79 tools at startup (which can degrade AI performance by up to 85%), tools can be organized into 7 modules that load on demand when lazy loading is enabled.
 
-### How Module Loading Works
+### How Module Loading Works (when `SHOPIFY_MCP_LAZY_LOADING=true`)
 
-1. **At startup:** Only the **Core Module** (15 tools) is loaded by default
+1. **At startup:** Only the **Core Module** (15 tools including meta-tools) is loaded
 2. **Discovery:** AI agents use `list-modules` to see available modules
 3. **Loading:** AI agents use `load-module` to enable additional tools
+
+> **Default behavior:** When lazy loading is disabled (default), all 79 domain tools are available immediately without module loading.
 4. **Suggestions:** Tool responses include hints about which modules to load next
 
 ### Module Dependency Diagram
@@ -570,9 +574,10 @@ shopify-mcp-admin uses a modular architecture to optimize AI agent performance.
 ```
 ┌─────────────────────────────────────────────────────────────────┐
 │                         CORE MODULE                              │
-│            (Always Loaded - 15 tools)                           │
-│   Products (7) • Inventory (4) • Store Info (2) • Meta (2)      │
+│        (Always Loaded - 13 domain + 2 meta* tools)              │
+│   Products (7) • Inventory (4) • Store Info (2) • Meta* (2)     │
 └─────────────────────────────────────────────────────────────────┘
+*Meta tools only available when lazy loading is enabled
         │
         ├──────────────────────────────────────────────────────────┐
         │                                                          │
@@ -593,7 +598,7 @@ shopify-mcp-admin uses a modular architecture to optimize AI agent performance.
 └───────────────────┘  └───────────────────┘  └───────────────────┘
 ```
 
-### Module: Core (15 tools) — Always Loaded
+### Module: Core (13-15 tools) — Always Loaded
 
 **Description:** Essential product and inventory management tools that form the foundation for most Shopify operations. Always loaded at startup.
 
@@ -606,7 +611,9 @@ shopify-mcp-admin uses a modular architecture to optimize AI agent performance.
 | 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` |
+| Meta Tools (2)* | `list-modules`, `load-module` |
+
+> *Meta tools are only included when lazy loading is enabled (`SHOPIFY_MCP_LAZY_LOADING=true`). When disabled (default), core has 13 domain tools.
 
 **Use Case:** Basic product catalog management, inventory tracking, and store information queries.
 
@@ -750,31 +757,32 @@ shopify-mcp-admin uses a modular architecture to optimize AI agent performance.
 
 ### 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%.
+Starting with v0.8.0, shopify-mcp-admin supports **modular 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 (All Tools Loaded):**
+- All 79 domain tools are loaded at startup for maximum compatibility
+- Works with Claude Desktop and all MCP clients
+- Server instructions describe all tools as immediately available
+- Module meta-tools (`list-modules`, `load-module`) are NOT registered (not needed)
 
-**Default Behavior (Lazy Loading Enabled):**
-- Only 15 core tools are loaded at startup
+**Optional: Enable Lazy Loading:**
+- Only 15 core tools are loaded at startup (13 domain + 2 meta-tools)
 - 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
+- Server instructions explain module discovery and loading
 
-### Breaking Changes
+> **Note:** Claude Desktop doesn't support dynamic tool list refresh, so lazy loading is disabled by default. Enable it for MCP clients that support `notifications/tools/list_changed`.
 
-| 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 |
+### Enabling Lazy Loading
 
-### Legacy Mode: Restore Previous Behavior
-
-If you prefer all tools loaded at startup (not recommended for optimal AI performance):
+For MCP clients that support dynamic tool refresh:
 
 ```bash
 # Option 1: Environment variable
-export SHOPIFY_MCP_LAZY_LOADING=false
+export SHOPIFY_MCP_LAZY_LOADING=true
 
-# Option 2: In Claude Desktop config
+# Option 2: In MCP client config
 {
   "mcpServers": {
     "shopify": {
@@ -783,56 +791,56 @@ export SHOPIFY_MCP_LAZY_LOADING=false
       "env": {
         "SHOPIFY_STORE_URL": "your-store.myshopify.com",
         "SHOPIFY_ACCESS_TOKEN": "shpat_xxxxx",
-        "SHOPIFY_MCP_LAZY_LOADING": "false"
+        "SHOPIFY_MCP_LAZY_LOADING": "true"
       }
     }
   }
 }
 ```
 
-### Migration Steps
+### Configuration Options
 
-1. **Review your use case** — Do you need all 81 tools? Most workflows only need a subset.
+1. **Default (all tools)** — All 79 domain tools available immediately. Best for Claude Desktop and MCP clients without dynamic tool refresh.
 
-2. **Choose a role preset** (recommended) — Set `SHOPIFY_MCP_ROLE` for pre-configured modules:
+2. **Role Preset** — Pre-configured module sets for specific workflows:
    ```bash
    export SHOPIFY_MCP_ROLE=product-manager
    ```
 
-3. **Or use on-demand loading** — Let AI agents discover and load modules as needed:
+3. **Lazy Loading** — Enable for MCP clients that support `notifications/tools/list_changed`:
+   ```bash
+   export SHOPIFY_MCP_LAZY_LOADING=true
+   ```
    - 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 |
+| **Default (all tools)** | 79 | Claude Desktop, maximum compatibility |
 | **Role Preset** | 15-81 based on role | Specific workflows (e.g., content manager) |
-| **Legacy Mode** | All 81 | Backward compatibility, full store admin |
+| **Lazy Loading** | 15 at startup | MCP clients with dynamic tool refresh |
 
 ### Performance Comparison
 
 | Mode | Tools at Startup | Est. Token Usage | AI Performance |
 |------|------------------|------------------|----------------|
-| Lazy Loading (default) | 15 | ~4,500 | ⭐⭐⭐ Optimal |
+| Lazy Loading | 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 |
+| full-access / Default | 79-81 | ~24,000 | ⭐ May degrade |
 
 ### Troubleshooting Module Loading
 
 | Issue | Solution |
 |-------|----------|
-| Tool not found after upgrade | Load the appropriate module: `load-module(module: "collections")` |
+| Tool not found with lazy loading | 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` |
+| Want modular lazy loading | Set `SHOPIFY_MCP_LAZY_LOADING=true` (requires MCP client that supports tool list refresh) |
 | AI agent loading too many modules | Use a role preset instead of on-demand loading |
 
 ---
@@ -881,8 +889,8 @@ npm run inspect:config
 
 MCP Inspector opens a web UI at `http://localhost:6274` where you can:
 
-- 📋 Browse registered tools with schemas (15 core tools by default, up to 81 with modules)
-- 📦 Test module loading via `list-modules` and `load-module`
+- 📋 Browse registered tools with schemas (79 tools by default, or 15 core tools with lazy loading)
+- 📦 Test module loading via `list-modules` and `load-module` (when lazy loading is enabled)
 - 📊 Access 9 MCP resources for store context
 - ▶️ Execute tools interactively and view results
 - 🔍 Inspect JSON-RPC protocol messages

package/dist/index.js

@@ -27,9 +27,11 @@ var configSchema = z.object({
   // 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)"),
   // 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)"),
+  // Default: false - loads all tools at startup for maximum compatibility
+  // Note: Claude Desktop doesn't support dynamic tool refresh via notifications,
+  // so lazy loading is disabled by default. Set to 'true' for clients that
+  // properly handle notifications/tools/list_changed.
+  SHOPIFY_MCP_LAZY_LOADING: z.string().optional().default("false").transform((val) => val === "true" || val === "1").describe("Enable lazy loading of tools via modules (default: false)"),
   // 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,
@@ -1324,38 +1326,7 @@ async function getStoreInfo() {
 var require2 = createRequire(import.meta.url);
 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.
-
-## 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
+var COMMON_INSTRUCTIONS = `## 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
@@ -1393,12 +1364,82 @@ Pre-configured module sets for common workflows:
 ## 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`;
+var LAZY_LOADING_INSTRUCTIONS = `This MCP server provides access to a Shopify store's Admin API.
+
+## 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
+
+${COMMON_INSTRUCTIONS}
 - After successful operations, note any module suggestions in the response`;
+var FULL_ACCESS_INSTRUCTIONS = `This MCP server provides access to a Shopify store's Admin API.
+
+## AVAILABLE TOOLS
+
+All tools are available immediately. This server provides comprehensive Shopify Admin API coverage:
+
+**Core Operations:**
+- Products: list, get, create, update, delete products and variants
+- Inventory: multi-location stock management, bulk queries, low inventory alerts
+- Store Info: basic info, limits, features, currencies, shipping, taxes, policies
+
+**Content Management:**
+- Pages: create, update, delete store pages
+- Blogs & Articles: manage blog content with SEO optimization
+
+**Collections:**
+- Create, update, delete collections
+- Manage product-collection relationships
+- Collection metafields for custom data
+
+**SEO & Redirects:**
+- URL redirects for SEO preservation
+- Bulk redirect operations for migrations
+- Product metafields for SEO data
+
+**International:**
+- Markets: manage selling regions
+- Translations: localize product content
+- Web presence configuration
+
+${COMMON_INSTRUCTIONS}`;
+function getServerInstructions(config) {
+  if (config && isLazyLoadingEnabled(config)) {
+    return LAZY_LOADING_INSTRUCTIONS;
+  }
+  return FULL_ACCESS_INSTRUCTIONS;
+}
 function getServerVersion() {
   return packageJson.version;
 }
-function createServer() {
+function createServer(config) {
+  const instructions = getServerInstructions(config);
   const server = new McpServer(
     // Server info (sent to clients in initialize response)
     {
@@ -1415,8 +1456,8 @@ function createServer() {
         logging: {}
         // Enable logging capability (AC-9.5.1.2)
       },
-      instructions: SERVER_INSTRUCTIONS,
-      // Provide Shopify context to AI agents (AC-9.5.1.1)
+      instructions,
+      // Provide mode-aware 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
@@ -3199,20 +3240,42 @@ function getRegisteredTools() {
     annotations: tool.annotations
   }));
 }
+function getAllRegisteredToolNames() {
+  return Array.from(registeredTools.keys());
+}
 function getToolByName(name) {
   return registeredTools.get(name);
 }
 function getToolNames() {
   return Array.from(registeredTools.keys());
 }
+var toolListChangedCallback = null;
+function setToolListChangedCallback(callback) {
+  toolListChangedCallback = callback;
+  log.debug("Tool list changed callback registered");
+}
+function notifyToolListChanged() {
+  if (toolListChangedCallback) {
+    log.info("\u{1F514} SENDING tools/list_changed notification to client");
+    toolListChangedCallback();
+  } else {
+    log.warn("\u26A0\uFE0F notifyToolListChanged called but no callback registered!");
+  }
+}
 function enableTool(name) {
   const tool = registeredTools.get(name);
   if (!tool) {
     log.debug(`Cannot enable tool: ${name} not found`);
     return false;
   }
+  const previousState = toolEnabledState.get(name);
+  const wasEnabled = previousState ?? true;
   toolEnabledState.set(name, true);
-  log.debug(`Tool enabled: ${name}`);
+  log.debug(`Tool enabled: ${name} (was: ${previousState}, wasEnabled: ${wasEnabled})`);
+  if (!wasEnabled) {
+    log.info(`\u{1F4E2} Tool ${name} state changed from disabled to enabled, triggering notification`);
+    notifyToolListChanged();
+  }
   return true;
 }
 function disableTool(name) {
@@ -3221,8 +3284,12 @@ function disableTool(name) {
     log.debug(`Cannot disable tool: ${name} not found`);
     return false;
   }
+  const wasEnabled = toolEnabledState.get(name) ?? true;
   toolEnabledState.set(name, false);
   log.debug(`Tool disabled: ${name}`);
+  if (wasEnabled) {
+    notifyToolListChanged();
+  }
   return true;
 }
 function isToolEnabled(name) {
@@ -14185,6 +14252,10 @@ function getSuggestionsForTool(toolName) {
 
 // src/tools/index.ts
 function setupToolHandlers(server) {
+  setToolListChangedCallback(() => {
+    server.sendToolListChanged();
+    log.debug("Sent tools/list_changed notification to clients");
+  });
   server.server.setRequestHandler(ListToolsRequestSchema, async () => {
     const tools = getRegisteredTools();
     log.debug(`tools/list returning ${tools.length} tools`);
@@ -14208,16 +14279,35 @@ function setupToolHandlers(server) {
     }
     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}${name !== rawName ? ` (received as "${rawName}")` : ""}`);
+      const allTools = getAllRegisteredToolNames();
+      const enabledTools = getRegisteredTools();
+      const totalRegistered = allTools.length;
+      const totalEnabled = enabledTools.length;
+      const similarTools = allTools.filter(
+        (t) => t.toLowerCase().includes(name.toLowerCase()) || name.toLowerCase().includes(t.toLowerCase())
+      );
+      let diagnosticInfo = `
+
+Diagnostics:
+- Total tools registered: ${totalRegistered}
+- Tools currently enabled: ${totalEnabled}`;
+      if (similarTools.length > 0) {
+        diagnosticInfo += `
+- Similar tool names found: ${similarTools.join(", ")}`;
+      }
+      const toolList = enabledTools.length > 0 ? `
+
+Enabled tools: ${enabledTools.map((t) => t.name).join(", ")}` : "\n\nNo tools are currently enabled. Try restarting your MCP client.";
+      log.warn(
+        `Tool not found: ${name}${name !== rawName ? ` (received as "${rawName}")` : ""}. Registered: ${totalRegistered}, Enabled: ${totalEnabled}`
+      );
       return {
         content: [
           {
             type: "text",
-            text: `Error: Tool "${name}" not found${name !== rawName ? ` (received as "${rawName}")` : ""}.
+            text: `Error: Tool "${name}" not found${name !== rawName ? ` (received as "${rawName}")` : ""}.${diagnosticInfo}
 
-Suggestion: Use tools/list to see available tools. ${toolList}`
+Suggestion: Use tools/list to refresh available tools. If this tool should exist, try restarting your MCP client (Claude Desktop).${toolList}`
           }
         ],
         isError: true
@@ -14358,11 +14448,14 @@ function registerAllTools(server) {
   registerGetStoreTaxesTool();
   registerGetStorePoliciesTool();
   registerGetStoreAlertsTool();
-  registerListModulesTool();
-  registerLoadModuleTool();
-  const totalToolCount = getToolNames().length;
   const config = getConfig();
-  if (isLazyLoadingEnabled(config)) {
+  const lazyLoadingEnabled = isLazyLoadingEnabled(config);
+  if (lazyLoadingEnabled) {
+    registerListModulesTool();
+    registerLoadModuleTool();
+  }
+  const totalToolCount = getToolNames().length;
+  if (lazyLoadingEnabled) {
     applyLazyLoading();
     const roleResult = applyRolePreset(config);
     const enabledCount = getRegisteredTools().length;
@@ -14375,8 +14468,12 @@ function registerAllTools(server) {
         `Lazy loading enabled: ${enabledCount} core tools active, ${totalToolCount - enabledCount} tools available via modules`
       );
     }
+    log.debug(
+      `Enabled tools: ${getRegisteredTools().map((t) => t.name).join(", ")}`
+    );
   } else {
-    log.info(`Lazy loading disabled (legacy mode): ${totalToolCount} tools registered`);
+    log.info(`Lazy loading disabled: ${totalToolCount} tools registered (all tools available)`);
+    log.debug(`All tools: ${getToolNames().join(", ")}`);
   }
 }
 function applyLazyLoading() {
@@ -14625,7 +14722,7 @@ if (args.includes("--version") || args.includes("-v")) {
 async function main() {
   try {
     const config = getConfig();
-    const server = createServer();
+    const server = createServer(config);
     registerResources(server);
     registerAllTools(server);
     const transportType = config.TRANSPORT;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@anton.andrusenko/shopify-mcp-admin",
-  "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",
+  "version": "1.1.1",
+  "description": "MCP server for Shopify Admin API - enables AI agents to manage Shopify stores with 79 tools for products, inventory, collections, content, SEO, metafields, markets & translations",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -24,6 +24,10 @@
     "inspect": "npx @modelcontextprotocol/inspector node dist/index.js",
     "inspect:dev": "npx @modelcontextprotocol/inspector npx tsx src/index.ts",
     "inspect:config": "npx @modelcontextprotocol/inspector --config mcp-inspector.json",
+    "fast-agent": "fast-agent",
+    "fast-agent:check": "fast-agent check",
+    "fast-agent:chat": "fast-agent go --servers shopify-mcp-admin",
+    "fast-agent:dev": "fast-agent go --servers shopify-mcp-admin-dev",
     "ci": "npm run lint && npm run typecheck && npm run test && npm run build",
     "version:patch": "npm version patch --no-git-tag-version",
     "version:minor": "npm version minor --no-git-tag-version",