@unchainedshop/api 4.8.21 → 4.8.23

package/lib/fastify/mcpHandler.js

@@ -1,102 +1,32 @@
+import { Readable } from 'node:stream';
 import { createLogger } from '@unchainedshop/logger';
+import handleMcpHttpRequest from "../mcp/handleMcpHttpRequest.js";
+import { toWebRequest } from "../mcp/nodeHttpBridge.js";
 const logger = createLogger('unchained:api:mcp');
-let StreamableHTTPServerTransport;
-let isInitializeRequest;
-let McpServer;
-try {
-    const mcpSDKServerLibrary = await import('@modelcontextprotocol/sdk/server/streamableHttp.js');
-    const mcpSDKClient = await import('@modelcontextprotocol/sdk/types.js');
-    const mcpSDKServer = await import('@modelcontextprotocol/sdk/server/mcp.js');
-    StreamableHTTPServerTransport = mcpSDKServerLibrary.StreamableHTTPServerTransport;
-    isInitializeRequest = mcpSDKClient.isInitializeRequest;
-    McpServer = mcpSDKServer.McpServer;
-}
-catch {
-    logger.warn(`optional peer npm package '@modelcontextprotocol/sdk' not installed, mcp will not work`);
-}
-const transports = {};
 const mcpHandler = async (req, res) => {
-    const user = req.unchainedContext.user;
-    if (!user) {
-        res.status(401);
-        res.header('WWW-Authenticate', `Bearer realm="Unchained MCP", error="invalid_token", resource="${process.env.ROOT_URL || 'http://localhost:4010'}",`);
-        return res.send(JSON.stringify({
-            error: 'invalid_token',
-            resource_metadata: `${process.env.ROOT_URL || 'http://localhost:4010'}/.well-known/oauth-protected-resource`,
-        }));
-    }
-    if (!(user.roles || []).includes('admin')) {
-        res.status(403);
-        return res.send(JSON.stringify({ error: 'forbidden', message: 'MCP requires admin privileges' }));
-    }
-    const currentUserId = user._id;
     try {
-        if (req.method === 'POST') {
-            const sessionId = req.headers['mcp-session-id'];
-            let transport;
-            if (sessionId && transports[sessionId]) {
-                if (transports[sessionId].userId !== currentUserId) {
-                    return res.status(404).send(JSON.stringify({
-                        jsonrpc: '2.0',
-                        error: {
-                            code: -32000,
-                            message: 'Bad Request: No valid session ID provided',
-                        },
-                        id: null,
-                    }));
-                }
-                Object.assign(transports[sessionId].context, req.unchainedContext);
-                transport = transports[sessionId].transport;
-            }
-            else if (!sessionId && isInitializeRequest(req.body)) {
-                const contextHolder = req.unchainedContext;
-                transport = new StreamableHTTPServerTransport({
-                    sessionIdGenerator: () => crypto.randomUUID(),
-                    onsessioninitialized: (sessionId) => {
-                        transports[sessionId] = { transport, userId: currentUserId, context: contextHolder };
-                    },
-                });
-                transport.onclose = () => {
-                    if (transport.sessionId) {
-                        delete transports[transport.sessionId];
-                    }
-                };
-                const roles = user.roles || [];
-                const { default: initMCPServer } = await import("../mcp/index.js");
-                const server = initMCPServer(new McpServer({
-                    name: 'Unchained MCP Server',
-                    version: '1.0.0',
-                }), contextHolder, roles);
-                await server.connect(transport);
-            }
-            else {
-                return res.status(400).send(JSON.stringify({
-                    jsonrpc: '2.0',
-                    error: {
-                        code: -32000,
-                        message: 'Bad Request: No valid session ID provided',
-                    },
-                    id: null,
-                }));
-            }
-            await transport.handleRequest(req.raw, res.raw, req.body);
-            return res;
-        }
-        else if (req.method === 'GET' || req.method === 'DELETE') {
-            const sessionId = req.headers['mcp-session-id'];
-            if (!sessionId || !transports[sessionId] || transports[sessionId].userId !== currentUserId) {
-                return res.status(400).send('Invalid or missing session ID');
-            }
-            Object.assign(transports[sessionId].context, req.unchainedContext);
-            const transport = transports[sessionId].transport;
-            await transport.handleRequest(req.raw, res.raw);
-            return res;
-        }
-        return res.status(405).send('Method Not Allowed');
+        const bodyText = req.method === 'POST' && req.body !== undefined ? JSON.stringify(req.body) : undefined;
+        const response = await handleMcpHttpRequest(req.unchainedContext, toWebRequest(req.raw, res.raw, bodyText), req.method === 'POST' ? req.body : undefined);
+        res.status(response.status);
+        response.headers.forEach((value, key) => {
+            if (key === 'set-cookie')
+                return;
+            res.header(key, value);
+        });
+        const setCookie = response.headers.getSetCookie();
+        if (setCookie.length)
+            res.header('set-cookie', setCookie);
+        if (!response.body)
+            return res.send();
+        return res.send(Readable.fromWeb(response.body));
     }
-    catch (e) {
-        logger.error(e);
-        return res.status(503).send({ name: e.name, code: e.code, message: e.message });
+    catch (error) {
+        logger.error(error);
+        if (!res.sent) {
+            return res.status(500).send({ error: 'Internal Server Error' });
+        }
+        res.raw.destroy();
+        return res;
     }
 };
 export default mcpHandler;

package/lib/locale-context.d.ts

@@ -6,10 +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>;
+}, unchainedAPI: UnchainedCore], UnchainedLocaleContext>;
 export declare const getLocaleContext: ({ getHeader, }: {
     getHeader: UnchainedHTTPServerContext["getHeader"];
 }, unchainedAPI: UnchainedCore) => Promise<UnchainedLocaleContext>;

package/lib/locale-context.js

@@ -1,9 +1,6 @@
-import { resolveBestSupported, resolveBestCurrency } from '@unchainedshop/utils';
-import pMemoize from 'p-memoize';
-import ExpiryMap from 'expiry-map';
+import { resolveBestSupported, resolveBestCurrency, memoizeWithTTL } from '@unchainedshop/utils';
 import { createLogger } from '@unchainedshop/logger';
 const logger = createLogger('unchained:api');
-const memoizeCache = new ExpiryMap(process.env.NODE_ENV === 'production' ? 1000 * 60 : 1);
 const uncachedResolveDefaultContext = async ({ acceptLang, acceptCountry }, unchainedAPI) => {
     const languages = await unchainedAPI.modules.languages.findLanguages({ includeInactive: false }, { projection: { isoCode: 1, isActive: 1 } });
     const countries = await unchainedAPI.modules.countries.findCountries({ includeInactive: false }, { projection: { isoCode: 1, isActive: 1 } });
@@ -19,8 +16,8 @@ const uncachedResolveDefaultContext = async ({ acceptLang, acceptCountry }, unch
     };
     return newContext;
 };
-export const resolveDefaultContext = pMemoize(uncachedResolveDefaultContext, {
-    cache: memoizeCache,
+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/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

@@ -179,9 +179,7 @@ export declare const actionValidators: {
         assortmentMediaId: z.ZodMiniString<string>;
     }, z.core.$strip>;
 };
-export declare const AssortmentManagementSchema: {
-    action: z.core.$ZodType<string>;
-} & Record<string, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+export declare const AssortmentManagementSchema: import("@modelcontextprotocol/server").StandardSchemaWithJSON<import("../../utils/sharedSchemas.ts").ManagementParams, import("../../utils/sharedSchemas.ts").ManagementParams>;
 export type { ManagementParams as AssortmentManagementParams } from '../../utils/sharedSchemas.ts';
 export type ActionName = keyof typeof actionValidators;
 export type Params<T extends ActionName> = z.infer<(typeof actionValidators)[T]>;

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

@@ -109,9 +109,7 @@ export declare const actionValidators: {
         filterOptionValue: z.ZodMiniOptional<z.ZodMiniString<string>>;
     }, z.core.$strip>;
 };
-export declare const FilterManagementSchema: {
-    action: z.core.$ZodType<string>;
-} & Record<string, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+export declare const FilterManagementSchema: import("@modelcontextprotocol/server").StandardSchemaWithJSON<import("../../utils/sharedSchemas.ts").ManagementParams, import("../../utils/sharedSchemas.ts").ManagementParams>;
 export type { ManagementParams as FilterManagementParams } from '../../utils/sharedSchemas.ts';
 export type ActionName = keyof typeof actionValidators;
 export type Params<T extends ActionName> = z.infer<(typeof actionValidators)[T]>;

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

@@ -86,9 +86,7 @@ export declare const actionValidators: {
         }>;
     }, z.core.$strip>;
 };
-export declare const LocalizationManagementSchema: {
-    action: z.core.$ZodType<string>;
-} & Record<string, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+export declare const LocalizationManagementSchema: import("@modelcontextprotocol/server").StandardSchemaWithJSON<import("../../utils/sharedSchemas.ts").ManagementParams, import("../../utils/sharedSchemas.ts").ManagementParams>;
 export type { ManagementParams as LocalizationManagementParams } from '../../utils/sharedSchemas.ts';
 export type ActionName = keyof typeof actionValidators;
 export type Params<T extends ActionName> = z.infer<(typeof actionValidators)[T]>;

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));
 };

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

@@ -135,9 +135,7 @@ export declare const actionValidators: {
         comment: z.ZodMiniOptional<z.ZodMiniString<string>>;
     }, z.core.$strip>;
 };
-export declare const OrderManagementSchema: {
-    action: z.core.$ZodType<string>;
-} & Record<string, z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+export declare const OrderManagementSchema: import("@modelcontextprotocol/server").StandardSchemaWithJSON<import("../../utils/sharedSchemas.ts").ManagementParams, import("../../utils/sharedSchemas.ts").ManagementParams>;
 export type { ManagementParams as OrderManagementParams } from '../../utils/sharedSchemas.ts';
 export type ActionName = keyof typeof actionValidators;
 export type Params<T extends ActionName> = z.infer<(typeof actionValidators)[T]>;

package/lib/mcp/tools/product/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 registerProductTools: (server: McpServer, context: Context) => void;