@unchainedshop/api 5.0.0-alpha.1 → 5.0.0-alpha.3

package/lib/loaders/tokenExportStatusLoader.js

@@ -0,0 +1,31 @@
+import { TokenStatus } from '@unchainedshop/core-warehousing';
+import { WorkStatus } from '@unchainedshop/core-worker';
+import DataLoader from 'dataloader';
+export default (unchainedAPI) => new DataLoader(async (queries) => {
+    const tokensNeedingWorkCheck = [];
+    for (const { token } of queries) {
+        if (!(token.walletAddress && !token.userId)) {
+            tokensNeedingWorkCheck.push(token);
+        }
+    }
+    let exportingTokenIds;
+    if (tokensNeedingWorkCheck.length > 0) {
+        const workItems = await unchainedAPI.modules.worker.findWorkQueue({
+            types: ['EXPORT_TOKEN'],
+            status: [WorkStatus.NEW, WorkStatus.ALLOCATED],
+        });
+        exportingTokenIds = new Set(workItems.map((item) => item.input?.token?._id).filter(Boolean));
+    }
+    else {
+        exportingTokenIds = new Set();
+    }
+    return queries.map(({ token }) => {
+        if (token.walletAddress && !token.userId) {
+            return TokenStatus.DECENTRALIZED;
+        }
+        if (exportingTokenIds.has(token._id)) {
+            return TokenStatus.EXPORTING;
+        }
+        return TokenStatus.CENTRALIZED;
+    });
+});

package/lib/locale-context.d.ts

@@ -6,12 +6,10 @@ export interface UnchainedLocaleContext {
     currencyCode: string;
 }
 export type GetHeaderFn = (key: string) => string | string[];
-export declare const resolveDefaultContext: (({ acceptLang, acceptCountry }: {
+export declare const resolveDefaultContext: import("@unchainedshop/utils/lib/memoize-with-ttl.js").MemoizedWithTTL<[{
     acceptLang: any;
     acceptCountry: any;
-}, unchainedAPI: UnchainedCore) => Promise<UnchainedLocaleContext>) & {
-    clear: () => void;
-};
+}, unchainedAPI: UnchainedCore], UnchainedLocaleContext>;
 export declare const getLocaleContext: ({ getHeader, }: {
     getHeader: UnchainedHTTPServerContext["getHeader"];
 }, unchainedAPI: UnchainedCore) => Promise<UnchainedLocaleContext>;

package/lib/locale-context.js

@@ -16,7 +16,8 @@ const uncachedResolveDefaultContext = async ({ acceptLang, acceptCountry }, unch
     };
     return newContext;
 };
-export const resolveDefaultContext = memoizeWithTTL(uncachedResolveDefaultContext, process.env.NODE_ENV === 'production' ? 1000 * 60 : 1, {
+export const resolveDefaultContext = memoizeWithTTL(uncachedResolveDefaultContext, {
+    ttl: process.env.NODE_ENV === 'production' ? 1000 * 60 : 1,
     cacheKey: (args) => {
         const [{ acceptLang, acceptCountry }] = args;
         return `${acceptLang}-${acceptCountry}`;

package/lib/mcp/handleMcpHttpRequest.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../context.ts';
+export default function handleMcpHttpRequest(context: Context | undefined, request: Request, parsedBody?: unknown): Promise<Response>;

package/lib/mcp/handleMcpHttpRequest.js

@@ -0,0 +1,83 @@
+import { createLogger } from '@unchainedshop/logger';
+import createMcpServer from "./index.js";
+import { isPeerNotInstalledError } from "../utils/optionalPeerError.js";
+const logger = createLogger('unchained:api:mcp');
+let createMcpHandler;
+let McpServer;
+let hostHeaderValidationResponse;
+let originValidationResponse;
+let localhostAllowedHostnames;
+let localhostAllowedOrigins;
+try {
+    const mcpSDKServer = await import('@modelcontextprotocol/server');
+    createMcpHandler = mcpSDKServer.createMcpHandler;
+    McpServer = mcpSDKServer.McpServer;
+    hostHeaderValidationResponse = mcpSDKServer.hostHeaderValidationResponse;
+    originValidationResponse = mcpSDKServer.originValidationResponse;
+    localhostAllowedHostnames = mcpSDKServer.localhostAllowedHostnames;
+    localhostAllowedOrigins = mcpSDKServer.localhostAllowedOrigins;
+}
+catch (error) {
+    if (isPeerNotInstalledError('@modelcontextprotocol/server', error)) {
+        logger.warn(`optional peer npm package '@modelcontextprotocol/server' not installed, mcp will not work`);
+    }
+    else {
+        logger.error(`failed to load '@modelcontextprotocol/server'`, error);
+    }
+}
+let handler;
+const getHandler = () => {
+    handler ??= createMcpHandler(async ({ authInfo }) => {
+        const { context, roles } = authInfo.extra;
+        return createMcpServer(new McpServer({ name: 'Unchained MCP Server', version: '1.0.0' }), context, roles);
+    });
+    return handler;
+};
+const resourceUrl = () => process.env.ROOT_URL || 'http://localhost:4010';
+const configuredHostname = () => {
+    try {
+        return new URL(resourceUrl()).hostname;
+    }
+    catch {
+        return 'localhost';
+    }
+};
+const allowedHostnames = () => [...new Set([...localhostAllowedHostnames(), configuredHostname()])];
+const allowedOrigins = () => [...new Set([...localhostAllowedOrigins(), configuredHostname()])];
+export default async function handleMcpHttpRequest(context, request, parsedBody) {
+    const user = context?.user;
+    if (!user) {
+        return Response.json({
+            error: 'invalid_token',
+            resource_metadata: `${resourceUrl()}/.well-known/oauth-protected-resource`,
+        }, {
+            status: 401,
+            headers: {
+                'WWW-Authenticate': `Bearer realm="Unchained MCP", error="invalid_token", resource="${resourceUrl()}",`,
+            },
+        });
+    }
+    const roles = user.roles || [];
+    if (!roles.includes('admin')) {
+        return Response.json({ error: 'forbidden', message: 'MCP requires admin privileges' }, { status: 403 });
+    }
+    if (!createMcpHandler) {
+        return Response.json({
+            error: 'unavailable',
+            message: `MCP is enabled but the optional peer npm package '@modelcontextprotocol/server' is not installed`,
+        }, { status: 503 });
+    }
+    const validationFailure = hostHeaderValidationResponse(request, allowedHostnames()) ??
+        originValidationResponse(request, allowedOrigins());
+    if (validationFailure)
+        return validationFailure;
+    return getHandler().fetch(request, {
+        authInfo: {
+            token: 'unchained-context',
+            clientId: user._id,
+            scopes: roles,
+            extra: { context, roles },
+        },
+        parsedBody,
+    });
+}

package/lib/mcp/index.d.ts

@@ -1,3 +1,3 @@
-import type { McpServer as McpServerType } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer as McpServerType } from '@modelcontextprotocol/server';
 import type { Context } from '../context.ts';
 export default function createMcpServer(server: McpServerType, context: Context, roles: any): McpServerType;

package/lib/mcp/nodeHttpBridge.d.ts

@@ -0,0 +1,3 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare function toWebRequest(req: IncomingMessage, res: ServerResponse, bodyText?: string): Request;
+export declare function sendWebResponse(res: ServerResponse, response: Response): Promise<void>;

package/lib/mcp/nodeHttpBridge.js

@@ -0,0 +1,64 @@
+import { Readable, pipeline } from 'node:stream';
+export function toWebRequest(req, res, bodyText) {
+    const controller = new AbortController();
+    res.once('close', () => {
+        if (!res.writableFinished)
+            controller.abort();
+    });
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(req.headers)) {
+        if (Array.isArray(value)) {
+            for (const entry of value)
+                headers.append(key, entry);
+        }
+        else if (value != null) {
+            headers.set(key, value);
+        }
+    }
+    if (bodyText !== undefined)
+        headers.delete('content-length');
+    let url;
+    try {
+        url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+    }
+    catch {
+        try {
+            url = new URL(req.url || '/', 'http://localhost');
+        }
+        catch {
+            url = new URL('http://localhost/');
+        }
+    }
+    return new Request(url, {
+        method: req.method,
+        headers,
+        body: bodyText,
+        signal: controller.signal,
+    });
+}
+export async function sendWebResponse(res, response) {
+    if (res.destroyed || res.writableEnded) {
+        await response.body?.cancel().catch(() => undefined);
+        return;
+    }
+    const headers = {};
+    response.headers.forEach((value, key) => {
+        headers[key] = key === 'set-cookie' ? response.headers.getSetCookie() : value;
+    });
+    res.writeHead(response.status, headers);
+    if (!response.body) {
+        res.end();
+        return;
+    }
+    const nodeStream = Readable.fromWeb(response.body);
+    await new Promise((resolve, reject) => {
+        pipeline(nodeStream, res, (error) => {
+            if (!error || error.code === 'ERR_STREAM_PREMATURE_CLOSE') {
+                resolve();
+            }
+            else {
+                reject(error);
+            }
+        });
+    });
+}

package/lib/mcp/resources/localization.d.ts

@@ -1,3 +1,7 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import type { Context } from '../../context.ts';
+export declare function getShopLanguagesText(context: Context): Promise<string>;
+export declare function getShopCurrenciesText(context: Context): Promise<string>;
+export declare function getShopCountriesText(context: Context): Promise<string>;
+export declare function buildChatResourceContext(context: Context | undefined): Promise<string>;
 export declare const registerLocalizationResources: (server: McpServer, context: Context) => void;

package/lib/mcp/resources/localization.js

@@ -1,77 +1,101 @@
+import { createLogger } from '@unchainedshop/logger';
+const logger = createLogger('unchained:api:mcp');
+export async function getShopLanguagesText(context) {
+    const [languages, countries] = await Promise.all([
+        context.modules.languages.findLanguages({ includeInactive: false }),
+        context.modules.countries.findCountries({ includeInactive: false }),
+    ]);
+    const baseLanguageCodes = languages.map((l) => l.isoCode.toLowerCase());
+    const availableCountryCodes = countries.map((c) => c.isoCode.toUpperCase());
+    return JSON.stringify({
+        baseLanguages: languages.map((l) => ({
+            isoCode: l.isoCode,
+            name: l.isoCode,
+            isActive: l.isActive,
+        })),
+        availableCountries: availableCountryCodes,
+        localeFormat: 'Use base language codes (e.g., "en", "fr", "de") or language-country combinations (e.g., "en-US", "fr-CH") following BCP 47 format',
+        validationRule: `Any combination of base languages [${baseLanguageCodes.join(', ')}] with available countries [${availableCountryCodes.join(', ')}] is acceptable for locale codes, as long as it makes contextual sense (e.g., "en-US" , "de-CH" , but "ja-DE" would be unusual)`,
+        note: 'If a required base language is missing, ask the user if they want to add it using localization_management tool with action: CREATE',
+    }, null, 2);
+}
+export async function getShopCurrenciesText(context) {
+    const currencies = await context.modules.currencies.findCurrencies({ includeInactive: false });
+    return JSON.stringify({
+        currencies: currencies.map((c) => ({
+            isoCode: c.isoCode,
+            name: c.isoCode,
+            isActive: c.isActive,
+            decimals: c.decimals,
+        })),
+        note: 'If a required currency is missing, ask the user if they want to add it using localization_management tool with action: CREATE',
+    }, null, 2);
+}
+export async function getShopCountriesText(context) {
+    const countries = await context.modules.countries.findCountries({ includeInactive: false });
+    return JSON.stringify({
+        countries: countries.map((c) => ({
+            isoCode: c.isoCode,
+            name: c.isoCode,
+            isActive: c.isActive,
+        })),
+        note: 'If a required country is missing, ask the user if they want to add it using localization_management tool with action: CREATE',
+    }, null, 2);
+}
+export async function buildChatResourceContext(context) {
+    if (!context?.user?.roles?.includes('admin'))
+        return '';
+    const sections = await Promise.all([
+        ['shop-languages', getShopLanguagesText],
+        ['shop-currencies', getShopCurrenciesText],
+        ['shop-countries', getShopCountriesText],
+    ].map(async ([name, getText]) => {
+        try {
+            return `${name}:\n${await getText(context)}`;
+        }
+        catch (error) {
+            logger.error(`Failed to read resource ${name}: ${error.message}`);
+            return null;
+        }
+    }));
+    const body = sections.filter(Boolean).join('\n\n');
+    return body ? `\n\nAVAILABLE SHOP CONFIGURATION:\n${body}` : '';
+}
 export const registerLocalizationResources = (server, context) => {
-    server.resource('shop-languages', 'unchained://shop/languages', {
+    server.registerResource('shop-languages', 'unchained://shop/languages', {
         description: 'Available languages configured in the shop. Use these ISO codes when creating or updating products, filters, and assortments. Includes valid language-country dialect combinations.',
         mimeType: 'application/json',
-    }, async () => {
-        const [languages, countries] = await Promise.all([
-            context.modules.languages.findLanguages({ includeInactive: false }),
-            context.modules.countries.findCountries({ includeInactive: false }),
-        ]);
-        const baseLanguageCodes = languages.map((l) => l.isoCode.toLowerCase());
-        const availableCountryCodes = countries.map((c) => c.isoCode.toUpperCase());
-        return {
-            contents: [
-                {
-                    uri: 'unchained://shop/languages',
-                    mimeType: 'application/json',
-                    text: JSON.stringify({
-                        baseLanguages: languages.map((l) => ({
-                            isoCode: l.isoCode,
-                            name: l.isoCode,
-                            isActive: l.isActive,
-                        })),
-                        availableCountries: availableCountryCodes,
-                        localeFormat: 'Use base language codes (e.g., "en", "fr", "de") or language-country combinations (e.g., "en-US", "fr-CH") following BCP 47 format',
-                        validationRule: `Any combination of base languages [${baseLanguageCodes.join(', ')}] with available countries [${availableCountryCodes.join(', ')}] is acceptable for locale codes, as long as it makes contextual sense (e.g., "en-US" , "de-CH" , but "ja-DE" would be unusual)`,
-                        note: 'If a required base language is missing, ask the user if they want to add it using localization_management tool with action: CREATE',
-                    }, null, 2),
-                },
-            ],
-        };
-    });
-    server.resource('shop-currencies', 'unchained://shop/currencies', {
+    }, async () => ({
+        contents: [
+            {
+                uri: 'unchained://shop/languages',
+                mimeType: 'application/json',
+                text: await getShopLanguagesText(context),
+            },
+        ],
+    }));
+    server.registerResource('shop-currencies', 'unchained://shop/currencies', {
         description: 'Available currencies configured in the shop. Check decimal points for price conversions. All prices are stored as integers.',
         mimeType: 'application/json',
-    }, async () => {
-        const currencies = await context.modules.currencies.findCurrencies({ includeInactive: false });
-        return {
-            contents: [
-                {
-                    uri: 'unchained://shop/currencies',
-                    mimeType: 'application/json',
-                    text: JSON.stringify({
-                        currencies: currencies.map((c) => ({
-                            isoCode: c.isoCode,
-                            name: c.isoCode,
-                            isActive: c.isActive,
-                            decimals: c.decimals,
-                        })),
-                        note: 'If a required currency is missing, ask the user if they want to add it using localization_management tool with action: CREATE',
-                    }, null, 2),
-                },
-            ],
-        };
-    });
-    server.resource('shop-countries', 'unchained://shop/countries', {
+    }, async () => ({
+        contents: [
+            {
+                uri: 'unchained://shop/currencies',
+                mimeType: 'application/json',
+                text: await getShopCurrenciesText(context),
+            },
+        ],
+    }));
+    server.registerResource('shop-countries', 'unchained://shop/countries', {
         description: 'Available countries configured in the shop. Use these ISO codes for geographic operations.',
         mimeType: 'application/json',
-    }, async () => {
-        const countries = await context.modules.countries.findCountries({ includeInactive: false });
-        return {
-            contents: [
-                {
-                    uri: 'unchained://shop/countries',
-                    mimeType: 'application/json',
-                    text: JSON.stringify({
-                        countries: countries.map((c) => ({
-                            isoCode: c.isoCode,
-                            name: c.isoCode,
-                            isActive: c.isActive,
-                        })),
-                        note: 'If a required country is missing, ask the user if they want to add it using localization_management tool with action: CREATE',
-                    }, null, 2),
-                },
-            ],
-        };
-    });
+    }, async () => ({
+        contents: [
+            {
+                uri: 'unchained://shop/countries',
+                mimeType: 'application/json',
+                text: await getShopCountriesText(context),
+            },
+        ],
+    }));
 };

package/lib/mcp/tools/assortment/handlers/getAssortment.js

@@ -3,7 +3,7 @@ import { getNormalizedAssortmentDetails } from "../../../utils/getNormalizedAsso
 export default async function getAssortment(context, params) {
     const { modules } = context;
     const { assortmentId, slug } = params;
-    let query = {};
+    let query;
     if (assortmentId)
         query = { assortmentId };
     else if (slug)

package/lib/mcp/tools/assortment/index.d.ts

@@ -1,3 +1,3 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import type { Context } from '../../../context.ts';
 export declare const registerAssortmentTools: (server: McpServer, context: Context) => void;

package/lib/mcp/tools/assortment/index.js

@@ -1,4 +1,7 @@
 import { assortmentManagement, AssortmentManagementSchema } from "./assortmentManagement.js";
 export const registerAssortmentTools = (server, context) => {
-    server.tool('assortment_management', 'Unified assortment management system with comprehensive action-based operations: CREATE/UPDATE/REMOVE/GET/LIST/COUNT assortments, UPDATE_STATUS (activate/deactivate), ADD_MEDIA/REMOVE_MEDIA/REORDER_MEDIA/GET_MEDIA/UPDATE_MEDIA_TEXTS, ADD_PRODUCT/REMOVE_PRODUCT/GET_PRODUCTS/REORDER_PRODUCTS, ADD_FILTER/REMOVE_FILTER/GET_FILTERS/REORDER_FILTERS, ADD_LINK/REMOVE_LINK/GET_LINKS/REORDER_LINKS, GET_CHILDREN/SET_BASE, SEARCH_PRODUCTS, GET_TEXTS/GET_MEDIA_TEXTS. Supports comprehensive assortment management with type-specific validations and error handling.', AssortmentManagementSchema, async (params) => assortmentManagement(context, params));
+    server.registerTool('assortment_management', {
+        description: 'Unified assortment management system with comprehensive action-based operations: CREATE/UPDATE/REMOVE/GET/LIST/COUNT assortments, UPDATE_STATUS (activate/deactivate), ADD_MEDIA/REMOVE_MEDIA/REORDER_MEDIA/GET_MEDIA/UPDATE_MEDIA_TEXTS, ADD_PRODUCT/REMOVE_PRODUCT/GET_PRODUCTS/REORDER_PRODUCTS, ADD_FILTER/REMOVE_FILTER/GET_FILTERS/REORDER_FILTERS, ADD_LINK/REMOVE_LINK/GET_LINKS/REORDER_LINKS, GET_CHILDREN/SET_BASE, SEARCH_PRODUCTS, GET_TEXTS/GET_MEDIA_TEXTS. Supports comprehensive assortment management with type-specific validations and error handling.',
+        inputSchema: AssortmentManagementSchema,
+    }, async (params) => assortmentManagement(context, params));
 };

package/lib/mcp/tools/assortment/schemas.d.ts

@@ -193,11 +193,11 @@ export declare const AssortmentManagementSchema: {
     limit: z.ZodOptional<z.ZodNumber>;
     offset: z.ZodOptional<z.ZodNumber>;
     action: z.ZodEnum<{
+        LIST: "LIST";
         GET: "GET";
         CREATE: "CREATE";
         UPDATE: "UPDATE";
         REMOVE: "REMOVE";
-        LIST: "LIST";
         COUNT: "COUNT";
         GET_TEXTS: "GET_TEXTS";
         UPDATE_STATUS: "UPDATE_STATUS";
@@ -285,11 +285,11 @@ export declare const AssortmentManagementZodSchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
     offset: z.ZodOptional<z.ZodNumber>;
     action: z.ZodEnum<{
+        LIST: "LIST";
         GET: "GET";
         CREATE: "CREATE";
         UPDATE: "UPDATE";
         REMOVE: "REMOVE";
-        LIST: "LIST";
         COUNT: "COUNT";
         GET_TEXTS: "GET_TEXTS";
         UPDATE_STATUS: "UPDATE_STATUS";

package/lib/mcp/tools/filter/handlers/createFilter.js

@@ -1,16 +1,14 @@
-import { FilterDirector } from '@unchainedshop/core';
 import { getNormalizedFilterDetails } from "../../../utils/getNormalizedFilterDetails.js";
 export default async function createFilter(context, params) {
-    const { modules } = context;
+    const { modules, services } = context;
     const { filter, texts } = params;
     const { key, type, options = [] } = filter;
-    const newFilter = await modules.filters.create({
+    const newFilter = await services.filters.createFilter({
         key,
         type,
         options,
         isActive: true,
     });
-    await FilterDirector.invalidateProductIdCache(newFilter, context);
     if (texts && texts.length > 0) {
         await modules.filters.texts.updateTexts({ filterId: newFilter._id }, texts);
     }

package/lib/mcp/tools/filter/handlers/createFilterOption.js

@@ -1,16 +1,14 @@
-import { FilterDirector } from '@unchainedshop/core';
 import { FilterNotFoundError } from "../../../../errors.js";
 import { getNormalizedFilterDetails } from "../../../utils/getNormalizedFilterDetails.js";
 export default async function createFilterOption(context, params) {
-    const { modules } = context;
+    const { modules, services } = context;
     const { filterId, option, optionTexts } = params;
     if (!(await modules.filters.filterExists({ filterId }))) {
         throw new FilterNotFoundError({ filterId });
     }
-    const newOption = await modules.filters.createFilterOption(filterId, { value: option });
+    const newOption = await services.filters.createFilterOption(filterId, { value: option });
     if (!newOption)
         return { filter: null };
-    await FilterDirector.invalidateProductIdCache(newOption, context);
     if (optionTexts && optionTexts.length > 0) {
         await modules.filters.texts.updateTexts({ filterId, filterOptionValue: option }, optionTexts);
     }

package/lib/mcp/tools/filter/handlers/removeFilterOption.js

@@ -1,19 +1,17 @@
-import { FilterDirector } from '@unchainedshop/core';
 import { FilterNotFoundError } from "../../../../errors.js";
 import { getNormalizedFilterDetails } from "../../../utils/getNormalizedFilterDetails.js";
 export default async function removeFilterOption(context, params) {
-    const { modules } = context;
+    const { modules, services } = context;
     const { filterId, option } = params;
     if (!(await modules.filters.filterExists({ filterId }))) {
         throw new FilterNotFoundError({ filterId });
     }
-    const removedFilterOption = await modules.filters.removeFilterOption({
+    const removedFilterOption = await services.filters.removeFilterOption({
         filterId,
         filterOptionValue: option,
     });
     if (!removedFilterOption)
         return { filter: null };
-    await FilterDirector.invalidateProductIdCache(removedFilterOption, context);
     const normalizedFilter = await getNormalizedFilterDetails(filterId, context);
     return { filter: normalizedFilter };
 }

package/lib/mcp/tools/filter/handlers/updateFilter.js

@@ -1,12 +1,12 @@
 import { FilterNotFoundError } from "../../../../errors.js";
 import { getNormalizedFilterDetails } from "../../../utils/getNormalizedFilterDetails.js";
 export default async function updateFilter(context, params) {
-    const { modules } = context;
+    const { modules, services } = context;
     const { filterId, updateData } = params;
     if (!(await modules.filters.filterExists({ filterId }))) {
         throw new FilterNotFoundError({ filterId });
     }
-    await modules.filters.update(filterId, updateData);
+    await services.filters.updateFilter(filterId, updateData);
     const normalizedFilter = await getNormalizedFilterDetails(filterId, context);
     return { filter: normalizedFilter };
 }

package/lib/mcp/tools/filter/index.d.ts

@@ -1,3 +1,3 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import type { Context } from '../../../context.ts';
 export declare const registerFilterTools: (server: McpServer, context: Context) => void;

package/lib/mcp/tools/filter/index.js

@@ -1,4 +1,7 @@
 import { filterManagement, FilterManagementSchema } from "./filterManagement.js";
 export const registerFilterTools = (server, context) => {
-    server.tool('filter_management', 'Comprehensive filter management system with unified CRUD operations. Supports: CREATE (new filters with localized texts), UPDATE (modify filter properties), REMOVE (delete with assortment cleanup), GET (retrieve single filter), LIST (paginated search with sorting), COUNT (total counts), CREATE_OPTION/REMOVE_OPTION (manage filter options), UPDATE_TEXTS/GET_TEXTS (localization management). Action-based routing with proper validation and error handling.', FilterManagementSchema, async (params) => filterManagement(context, params));
+    server.registerTool('filter_management', {
+        description: 'Comprehensive filter management system with unified CRUD operations. Supports: CREATE (new filters with localized texts), UPDATE (modify filter properties), REMOVE (delete with assortment cleanup), GET (retrieve single filter), LIST (paginated search with sorting), COUNT (total counts), CREATE_OPTION/REMOVE_OPTION (manage filter options), UPDATE_TEXTS/GET_TEXTS (localization management). Action-based routing with proper validation and error handling.',
+        inputSchema: FilterManagementSchema,
+    }, async (params) => filterManagement(context, params));
 };

package/lib/mcp/tools/filter/schemas.d.ts

@@ -133,11 +133,11 @@ export declare const FilterManagementSchema: {
     limit: z.ZodOptional<z.ZodNumber>;
     offset: z.ZodOptional<z.ZodNumber>;
     action: z.ZodEnum<{
+        LIST: "LIST";
         GET: "GET";
         CREATE: "CREATE";
         UPDATE: "UPDATE";
         REMOVE: "REMOVE";
-        LIST: "LIST";
         COUNT: "COUNT";
         CREATE_OPTION: "CREATE_OPTION";
         REMOVE_OPTION: "REMOVE_OPTION";
@@ -189,11 +189,11 @@ export declare const FilterManagementZodSchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
     offset: z.ZodOptional<z.ZodNumber>;
     action: z.ZodEnum<{
+        LIST: "LIST";
         GET: "GET";
         CREATE: "CREATE";
         UPDATE: "UPDATE";
         REMOVE: "REMOVE";
-        LIST: "LIST";
         COUNT: "COUNT";
         CREATE_OPTION: "CREATE_OPTION";
         REMOVE_OPTION: "REMOVE_OPTION";

package/lib/mcp/tools/localization/index.d.ts

@@ -1,3 +1,3 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import type { Context } from '../../../context.ts';
 export declare const registerLocalizationTools: (server: McpServer, context: Context) => void;

package/lib/mcp/tools/localization/index.js

@@ -1,4 +1,7 @@
 import { localizationManagement, LocalizationManagementSchema } from "./localizationManagement.js";
 export const registerLocalizationTools = (server, context) => {
-    server.tool('localization_management', 'Unified localization management tool for localization operations across geographic, monetary, and language entities. Countries use 2-letter codes (US, DE, FR), currencies use 3-letter codes (USD, EUR, CHF) with optional blockchain support, languages use locale codes (en, de-CH).. Actions: CREATE (add new), UPDATE (modify existing), REMOVE (delete).', LocalizationManagementSchema, async (params) => localizationManagement(context, params));
+    server.registerTool('localization_management', {
+        description: 'Unified localization management tool for localization operations across geographic, monetary, and language entities. Countries use 2-letter codes (US, DE, FR), currencies use 3-letter codes (USD, EUR, CHF) with optional blockchain support, languages use locale codes (en, de-CH).. Actions: CREATE (add new), UPDATE (modify existing), REMOVE (delete).',
+        inputSchema: LocalizationManagementSchema,
+    }, async (params) => localizationManagement(context, params));
 };

package/lib/mcp/tools/localization/schemas.d.ts

@@ -132,11 +132,11 @@ export declare const LocalizationManagementSchema: {
     limit: z.ZodOptional<z.ZodNumber>;
     offset: z.ZodOptional<z.ZodNumber>;
     action: z.ZodEnum<{
+        LIST: "LIST";
         GET: "GET";
         CREATE: "CREATE";
         UPDATE: "UPDATE";
         REMOVE: "REMOVE";
-        LIST: "LIST";
         COUNT: "COUNT";
     }>;
     localizationType: z.ZodEnum<{
@@ -165,11 +165,11 @@ export declare const LocalizationManagementZodSchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodNumber>;
     offset: z.ZodOptional<z.ZodNumber>;
     action: z.ZodEnum<{
+        LIST: "LIST";
         GET: "GET";
         CREATE: "CREATE";
         UPDATE: "UPDATE";
         REMOVE: "REMOVE";
-        LIST: "LIST";
         COUNT: "COUNT";
     }>;
     localizationType: z.ZodEnum<{

package/lib/mcp/tools/order/index.d.ts

@@ -1,3 +1,3 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import type { Context } from '../../../context.ts';
 export declare const registerOrderTools: (server: McpServer, context: Context) => void;

package/lib/mcp/tools/order/index.js

@@ -1,4 +1,7 @@
 import { orderManagement, OrderManagementSchema } from "./orderManagement.js";
 export const registerOrderTools = (server, context) => {
-    server.tool('order_management', 'Unified order management and analytics system. Supports: LIST (get orders with filters and pagination), SALES_SUMMARY (daily sales analytics), MONTHLY_BREAKDOWN (12-month sales analysis), TOP_CUSTOMERS (highest spending customers), TOP_PRODUCTS (best-selling products). All actions support date filtering and provider-based segmentation with proper aggregation and normalization.', OrderManagementSchema, async (params) => orderManagement(context, params));
+    server.registerTool('order_management', {
+        description: 'Unified order management and analytics system. Supports: LIST (get orders with filters and pagination), SALES_SUMMARY (daily sales analytics), MONTHLY_BREAKDOWN (12-month sales analysis), TOP_CUSTOMERS (highest spending customers), TOP_PRODUCTS (best-selling products). All actions support date filtering and provider-based segmentation with proper aggregation and normalization.',
+        inputSchema: OrderManagementSchema,
+    }, async (params) => orderManagement(context, params));
 };