@unchainedshop/api 4.0.0-rc.16 → 4.0.0-rc.18

package/src/fastify/chatHandler.ts

@@ -1,5 +1,6 @@
 import { FastifyInstance, RouteHandlerMethod, FastifyRequest } from 'fastify';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import {
   convertToModelMessages,
   experimental_createMCPClient as createMCPClient,
@@ -41,18 +42,60 @@ const setupMCPChatHandler = (chatConfiguration: ChatConfiguration & any) => {
         return res.status(200).send();
       }
 
-      client = await createMCPClient({
-        transport: new StreamableHTTPClientTransport(new URL(unchainedMCPUrl), {
-          authProvider: null,
-          requestInit: {
-            headers: {
-              Cookie: req.headers.cookie || '',
-            },
+      const resourceTransport = new StreamableHTTPClientTransport(new URL(unchainedMCPUrl), {
+        requestInit: {
+          headers: {
+            Cookie: req.headers.cookie || '',
+          },
+        },
+      });
+
+      const sdkClient = new Client(
+        { name: 'unchained-chat-client', version: '1.0.0' },
+        {
+          capabilities: { resources: {} },
+        },
+      );
+      await sdkClient.connect(resourceTransport as any);
+
+      const transport = new StreamableHTTPClientTransport(new URL(unchainedMCPUrl), {
+        requestInit: {
+          headers: {
+            Cookie: req.headers.cookie || '',
           },
-        }) as MCPTransport,
+        },
+      });
+
+      client = await createMCPClient({
+        transport: transport as MCPTransport,
       });
 
       const defaultUnchainedTools = await client.tools();
+
+      let resourceContext = '';
+      try {
+        const resources = await sdkClient.listResources();
+        if (resources?.resources) {
+          const resourceTexts = await Promise.all(
+            resources.resources.map(async (resource) => {
+              try {
+                const content = await sdkClient.readResource({ uri: resource.uri });
+                if (content?.contents?.[0]?.text) {
+                  return `${resource.name}:\n${content.contents[0].text}`;
+                }
+              } catch (e) {
+                logger.error(`Failed to read resource ${resource.uri}:`, e);
+              }
+              return null;
+            }),
+          );
+          resourceContext =
+            '\n\nAVAILABLE SHOP CONFIGURATION:\n' + resourceTexts.filter(Boolean).join('\n\n');
+        }
+      } catch (e) {
+        logger.error('Failed to fetch MCP resources:', e);
+      }
+
       const tools: ToolSet = {
         ...defaultUnchainedTools,
         ...additionalTools,
@@ -90,11 +133,26 @@ const setupMCPChatHandler = (chatConfiguration: ChatConfiguration & any) => {
           providerOptions: { anthropic: { cacheControl: { type: 'ephemeral' } } },
         };
       }
+
+      const MAX_MESSAGES = 10;
+      let startIndex = Math.max(0, normalizedMessages.length - MAX_MESSAGES);
+      while (startIndex < normalizedMessages.length) {
+        const msg = normalizedMessages[startIndex];
+        const hasOrphanedToolResult =
+          Array.isArray(msg.content) && msg.content.some((c: any) => c.type === 'tool-result');
+
+        if (!hasOrphanedToolResult) break;
+        startIndex++;
+      }
+      const messagesToInclude = normalizedMessages.slice(startIndex);
+
       const result = streamText({
         stopWhen: stepCountIs(500),
+        temperature: 0.2,
+        maxRetries: 3,
         ...restChatConfig,
-        messages: normalizedMessages.slice(-20),
-        system,
+        messages: messagesToInclude,
+        system: system + resourceContext,
         tools: cacheControlledTools,
         onFinish: async () => {
           await client?.close();

package/src/fastify/ercMetadataHandler.ts

@@ -27,7 +27,7 @@ const ercMetadataHandler: RouteHandlerMethod = async (
     const product = await loaders.productLoader.load({ productId });
 
     const [token] = await modules.warehousing.findTokens({
-      chainTokenId: (tokenFileName || localeOrTokenFilename).toLowerCase().replace('.json', ''),
+      tokenSerialNumber: (tokenFileName || localeOrTokenFilename).toLowerCase().replace('.json', ''),
       contractAddress: product?.tokenization?.contractAddress,
     });
 

package/src/fastify/index.ts

@@ -38,7 +38,7 @@ const {
   UNCHAINED_COOKIE_NAME = 'unchained_token',
   UNCHAINED_COOKIE_PATH = '/',
   UNCHAINED_COOKIE_DOMAIN,
-  UNCHAINED_COOKIE_SAMESITE,
+  UNCHAINED_COOKIE_SAMESITE = 'none',
   UNCHAINED_COOKIE_INSECURE,
 } = process.env;
 
@@ -160,7 +160,7 @@ export const connect = (
   if (!fastify.hasPlugin('@fastify/cookie')) {
     fastify.register(fastifyCookie);
   }
-  fastify.register(fastifySession, {
+  fastify.register(fastifySession as any, {
     secret: process.env.UNCHAINED_TOKEN_SECRET,
     cookieName,
     store: MongoStore.create({

package/src/fastify/tempUploadHandler.ts

@@ -36,6 +36,7 @@ const tempUploadHandler: RouteHandlerMethod = async (
 
     const fileUploadAdapter = getFileAdapter();
     const rawUrl = await fileUploadAdapter.createDownloadURL(file);
+    if (!rawUrl) throw new Error('Could not create download URL for file');
     const url = context.modules.files.normalizeUrl(rawUrl, {});
     res.status(200);
     return res.send({ fileId: file._id, url, expires: expires.toISOString() });

package/src/loaders/assortmentLinksLoader.ts

@@ -7,9 +7,9 @@ export default (unchainedAPI: UnchainedCore) =>
     { parentAssortmentId?: string; childAssortmentId?: string; assortmentId?: string },
     AssortmentLink[]
   >(async (queries) => {
-    const parentAssortmentIds = queries.flatMap((q) => q.parentAssortmentId).filter(Boolean);
-    const childAssortmentIds = queries.flatMap((q) => q.childAssortmentId).filter(Boolean);
-    const assortmentIds = queries.flatMap((q) => q.assortmentId).filter(Boolean);
+    const parentAssortmentIds = queries.flatMap((q) => q.parentAssortmentId).filter(Boolean) as string[];
+    const childAssortmentIds = queries.flatMap((q) => q.childAssortmentId).filter(Boolean) as string[];
+    const assortmentIds = queries.flatMap((q) => q.assortmentId).filter(Boolean) as string[];
 
     const allLinks = await unchainedAPI.modules.assortments.links.findLinks({
       assortmentIds: [...new Set([...parentAssortmentIds, ...childAssortmentIds, ...assortmentIds])],
@@ -38,9 +38,12 @@ export default (unchainedAPI: UnchainedCore) =>
       } else if (q.childAssortmentId) {
         return childAssortmentLinkMap[q.childAssortmentId] || [];
       }
-      return [
-        ...(parentAssortmentLinkMap[q.assortmentId] || []),
-        ...(childAssortmentLinkMap[q.assortmentId] || []),
-      ];
+      if (q.assortmentId) {
+        return [
+          ...(parentAssortmentLinkMap[q.assortmentId] || []),
+          ...(childAssortmentLinkMap[q.assortmentId] || []),
+        ];
+      }
+      return [];
     });
   });

package/src/loaders/assortmentMediasLoader.ts

@@ -3,7 +3,7 @@ import { AssortmentMediaType } from '@unchainedshop/core-assortments';
 import DataLoader from 'dataloader';
 
 export default (unchainedAPI: UnchainedCore) =>
-  new DataLoader<{ assortmentId?: string }, AssortmentMediaType[]>(async (queries) => {
+  new DataLoader<{ assortmentId: string }, AssortmentMediaType[]>(async (queries) => {
     const assortmentIds = [...new Set(queries.map((q) => q.assortmentId).filter(Boolean))];
     const assortmentMediaItems = await unchainedAPI.modules.assortments.media.findAssortmentMedias({
       assortmentId: { $in: assortmentIds },

package/src/loaders/filterTextLoader.ts

@@ -5,22 +5,23 @@ import { FilterText } from '@unchainedshop/core-filters';
 import buildTextMap from './buildTextMap.js';
 
 export default (unchainedAPI: UnchainedCore) =>
-  new DataLoader<{ filterId: string; filterOptionValue?: string; locale: Intl.Locale }, FilterText>(
-    async (queries) => {
-      const filterIds = [...new Set(queries.map((q) => q.filterId).filter(Boolean))];
+  new DataLoader<
+    { filterId: string; filterOptionValue?: string | null; locale: Intl.Locale },
+    FilterText
+  >(async (queries) => {
+    const filterIds = [...new Set(queries.map((q) => q.filterId).filter(Boolean))];
 
-      const texts = await unchainedAPI.modules.filters.texts.findTexts(
-        { filterId: { $in: filterIds } },
-        {
-          sort: {
-            filterId: 1,
-          },
+    const texts = await unchainedAPI.modules.filters.texts.findTexts(
+      { filterId: { $in: filterIds } },
+      {
+        sort: {
+          filterId: 1,
         },
-      );
+      },
+    );
 
-      const localeMap = buildLocaleMap(queries, texts);
-      const textsMap = buildTextMap(localeMap, texts, (text) => text.filterId + text.filterOptionValue);
+    const localeMap = buildLocaleMap(queries, texts);
+    const textsMap = buildTextMap(localeMap, texts, (text) => text.filterId + text.filterOptionValue);
 
-      return queries.map((q) => textsMap[q.locale + q.filterId + q.filterOptionValue]);
-    },
-  );
+    return queries.map((q) => textsMap[q.locale + q.filterId + q.filterOptionValue]);
+  });

package/src/loaders/productMediasLoader.ts

@@ -3,7 +3,7 @@ import { ProductMedia } from '@unchainedshop/core-products';
 import DataLoader from 'dataloader';
 
 export default (unchainedAPI: UnchainedCore) =>
-  new DataLoader<{ productId?: string }, ProductMedia[]>(async (queries) => {
+  new DataLoader<{ productId: string }, ProductMedia[]>(async (queries) => {
     const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
     const productMediaItems = await unchainedAPI.modules.products.media.findProductMedias({
       productId: { $in: productIds },

package/src/loaders/productProxiesLoader.ts

@@ -3,7 +3,7 @@ import { Product } from '@unchainedshop/core-products';
 import DataLoader from 'dataloader';
 
 export default (unchainedAPI: UnchainedCore) =>
-  new DataLoader<{ productId?: string }, Product[]>(async (queries) => {
+  new DataLoader<{ productId: string }, Product[]>(async (queries) => {
     const productIds = [...new Set(queries.map((q) => q.productId).filter(Boolean))];
 
     const productProxies = await unchainedAPI.modules.products.findProducts({

package/src/loaders/utils.ts

@@ -21,7 +21,7 @@ export function buildLocaleMap(
     Object.fromEntries(queries.map((q) => [q.locale.baseName, q.locale])),
   );
 
-  const textLocales: string[] = [...new Set(texts.map((t) => t.locale))];
+  const textLocales = [...new Set(texts.map((t) => t.locale))].filter(Boolean) as string[];
   const localeMap = {};
   for (const queryLocale of queryLocales) {
     const potentialMatches = getLocaleStrings(queryLocale);

package/src/locale-context.ts

@@ -37,13 +37,13 @@ const uncachedResolveDefaultContext = async (
     (country) => country.isoCode.toUpperCase() === locale?.region?.toUpperCase(),
   )?.defaultCurrencyCode;
 
-  const currencyCode = resolveBestCurrency(defaultCurrencyCode, currencies);
+  const currencyCode = resolveBestCurrency(defaultCurrencyCode || null, currencies);
 
   logger.debug(`Locale Context: Resolved ${locale?.baseName} ${currencyCode}`);
 
   const newContext: UnchainedLocaleContext = {
     locale,
-    countryCode: locale?.region,
+    countryCode: locale.region as string,
     currencyCode,
   };
 

package/src/mcp/index.ts

@@ -6,9 +6,11 @@ import { registerProductTools } from './tools/product/index.js';
 import { registerLocalizationTools } from './tools/localization/index.js';
 import { registerProviderTools } from './tools/provider/index.js';
 import { registerOrderTools } from './tools/order/index.js';
+import { registerQuotationTools } from './tools/quotation/index.js';
 import { registerAssortmentTools } from './tools/assortment/index.js';
 import { registerUsersTools } from './tools/users/index.js';
 import { registerSystemTools } from './tools/system/index.js';
+import { registerLocalizationResources } from './resources/localization.js';
 
 export default function createMcpServer(context: Context, roles) {
   const server = new McpServer({
@@ -19,6 +21,9 @@ export default function createMcpServer(context: Context, roles) {
   if (!roles?.includes('admin')) {
     return server;
   }
+
+  registerLocalizationResources(server, context);
+
   registerFilterTools(server, context);
   registerProductTools(server, context);
   registerAssortmentTools(server, context);
@@ -26,6 +31,7 @@ export default function createMcpServer(context: Context, roles) {
   registerSystemTools(server, context);
   registerProviderTools(server, context);
   registerOrderTools(server, context);
+  registerQuotationTools(server, context);
   registerUsersTools(server, context);
   return server;
 }

package/src/mcp/resources/localization.ts

@@ -0,0 +1,129 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Context } from '../../context.js';
+
+export const registerLocalizationResources = (server: McpServer, context: Context) => {
+  server.resource(
+    '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',
+      annotations: {
+        audience: ['assistant'],
+        priority: 1,
+        lastModified: '2025-09-30T15:00:58Z',
+      },
+    },
+    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',
+    {
+      description:
+        'Available currencies configured in the shop. Check decimal points for price conversions. All prices are stored as integers.',
+      mimeType: 'application/json',
+      annotations: {
+        audience: ['assistant'],
+        priority: 1,
+        lastModified: '2025-09-30T15:00:58Z',
+      },
+    },
+    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',
+    {
+      description:
+        'Available countries configured in the shop. Use these ISO codes for geographic operations.',
+      mimeType: 'application/json',
+      annotations: {
+        audience: ['assistant'],
+        priority: 1,
+        lastModified: '2025-09-30T15:00:58Z',
+      },
+    },
+    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,
+            ),
+          },
+        ],
+      };
+    },
+  );
+};

package/src/mcp/tools/assortment/handlers/removeAssortment.ts

@@ -9,6 +9,6 @@ export default async function removeAssortment(context: Context, params: Params<
   const assortment = await modules.assortments.findAssortment({ assortmentId });
   if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
 
-  await modules.assortments.delete(assortmentId);
-  return { success: true };
+  const deletedAssortment = await modules.assortments.delete(assortmentId);
+  return { success: Boolean(deletedAssortment) };
 }

package/src/mcp/tools/assortment/handlers/removeAssortmentFilter.ts

@@ -5,6 +5,6 @@ export default async function removeAssortmentFilter(context: Context, params: P
   const { modules } = context;
   const { assortmentFilterId } = params;
 
-  await modules.assortments.filters.delete(assortmentFilterId);
-  return { success: true };
+  const deletedAssortmentFilter = await modules.assortments.filters.delete(assortmentFilterId);
+  return { success: Boolean(deletedAssortmentFilter) };
 }

package/src/mcp/tools/assortment/handlers/removeAssortmentLink.ts

@@ -9,6 +9,6 @@ export default async function removeAssortmentLink(context: Context, params: Par
   const existing = await modules.assortments.links.findLink({ assortmentLinkId });
   if (!existing) throw new Error(`Assortment link not found: ${assortmentLinkId}`);
 
-  await modules.assortments.links.delete(assortmentLinkId);
-  return { success: true };
+  const deletedAssortmentLink = await modules.assortments.links.delete(assortmentLinkId);
+  return { success: Boolean(deletedAssortmentLink) };
 }

package/src/mcp/tools/assortment/handlers/removeAssortmentProduct.ts

@@ -8,6 +8,6 @@ export default async function removeAssortmentProduct(
   const { modules } = context;
   const { assortmentProductId } = params;
 
-  await modules.assortments.products.delete(assortmentProductId);
-  return { success: true };
+  const deletedAssortmentProduct = await modules.assortments.products.delete(assortmentProductId);
+  return { success: Boolean(deletedAssortmentProduct) };
 }

package/src/mcp/tools/assortment/handlers/updateAssortmentMediaTexts.ts

@@ -1,3 +1,4 @@
+import { AssortmentMediaText } from '@unchainedshop/core-assortments';
 import { Context } from '../../../../context.js';
 import { AssortmentMediaNotFoundError } from '../../../../errors.js';
 import { Params } from '../schemas.js';
@@ -14,7 +15,7 @@ export default async function updateAssortmentMediaTexts(
 
   const texts_updated = await modules.assortments.media.texts.updateMediaTexts(
     assortmentMediaId,
-    mediaTexts,
+    mediaTexts as AssortmentMediaText[],
   );
   return { texts: texts_updated };
 }

package/src/mcp/tools/assortment/schemas.ts

@@ -199,7 +199,7 @@ export const actionValidators = {
   }),
 
   GET_CHILDREN: z.object({
-    assortmentId: z.string().min(1).optional().describe('Assortment ID (optional for root-level)'),
+    assortmentId: z.string().min(1).describe('Assortment ID (optional for root-level)'),
     includeInactive: z.boolean().optional().describe('Include inactive children'),
   }),
 

package/src/mcp/tools/filter/handlers/createFilter.ts

@@ -2,6 +2,7 @@ import { Context } from '../../../../context.js';
 import { FilterDirector } from '@unchainedshop/core';
 import { getNormalizedFilterDetails } from '../../../utils/getNormalizedFilterDetails.js';
 import { Params } from '../schemas.js';
+import { FilterText } from '@unchainedshop/core-filters';
 
 export default async function createFilter(context: Context, params: Params<'CREATE'>) {
   const { modules } = context;
@@ -18,7 +19,7 @@ export default async function createFilter(context: Context, params: Params<'CRE
   await FilterDirector.invalidateProductIdCache(newFilter, context);
 
   if (texts && texts.length > 0) {
-    await modules.filters.texts.updateTexts({ filterId: newFilter._id }, texts);
+    await modules.filters.texts.updateTexts({ filterId: newFilter._id }, texts as FilterText[]);
   }
 
   const normalizedFilter = await getNormalizedFilterDetails(newFilter._id, context);

package/src/mcp/tools/filter/handlers/createFilterOption.ts

@@ -3,6 +3,7 @@ import { FilterDirector } from '@unchainedshop/core';
 import { FilterNotFoundError } from '../../../../errors.js';
 import { getNormalizedFilterDetails } from '../../../utils/getNormalizedFilterDetails.js';
 import { Params } from '../schemas.js';
+import { FilterText } from '@unchainedshop/core-filters';
 
 export default async function createFilterOption(context: Context, params: Params<'CREATE_OPTION'>) {
   const { modules } = context;
@@ -12,11 +13,16 @@ export default async function createFilterOption(context: Context, params: Param
     throw new FilterNotFoundError({ filterId });
   }
 
-  const newOptions = await modules.filters.createFilterOption(filterId, { value: option });
-  await FilterDirector.invalidateProductIdCache(newOptions, context);
+  const newOption = await modules.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);
+    await modules.filters.texts.updateTexts(
+      { filterId, filterOptionValue: option },
+      optionTexts as FilterText[],
+    );
   }
 
   const normalizedFilter = await getNormalizedFilterDetails(filterId, context);

package/src/mcp/tools/filter/handlers/removeFilterOption.ts

@@ -16,6 +16,9 @@ export default async function removeFilterOption(context: Context, params: Param
     filterId,
     filterOptionValue: option,
   });
+
+  if (!removedFilterOption) return { filter: null };
+
   await FilterDirector.invalidateProductIdCache(removedFilterOption, context);
 
   const normalizedFilter = await getNormalizedFilterDetails(filterId, context);

package/src/mcp/tools/filter/handlers/updateFilterTexts.ts

@@ -1,3 +1,4 @@
+import { FilterText } from '@unchainedshop/core-filters';
 import { Context } from '../../../../context.js';
 import { FilterNotFoundError } from '../../../../errors.js';
 import { getNormalizedFilterDetails } from '../../../utils/getNormalizedFilterDetails.js';
@@ -13,7 +14,7 @@ export default async function updateFilterTexts(context: Context, params: Params
 
   const updatedTexts = await modules.filters.texts.updateTexts(
     { filterId, filterOptionValue: filterOptionValue || null },
-    textUpdates,
+    textUpdates as FilterText[],
   );
 
   const normalizedFilter = await getNormalizedFilterDetails(filterId, context);

package/src/mcp/tools/localization/index.ts

@@ -5,7 +5,7 @@ import { localizationManagement, LocalizationManagementSchema } from './localiza
 export const registerLocalizationTools = (server: McpServer, context: Context) => {
   server.tool(
     'localization_management',
-    'Unified localization management tool for all localization operations (CREATE, UPDATE, REMOVE, GET, LIST, COUNT) 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, fr-CA). Use action parameter to specify operation type.',
+    '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),
   );

package/src/mcp/tools/order/handlers/deliverOrder.ts

@@ -4,6 +4,7 @@ import {
   OrderNotFoundError,
   OrderWrongDeliveryStatusError,
   OrderWrongStatusError,
+  OrderDeliveryNotFoundError,
 } from '../../../../errors.js';
 import { getNormalizedOrderDetails } from '../../../utils/getNormalizedOrderDetails.js';
 import { Params } from '../schemas.js';
@@ -18,9 +19,13 @@ export default async function deliverOrder(context: Context, params: Params<'DEL
     throw new OrderWrongStatusError({ status: order.status });
   }
 
-  const orderDelivery = await modules.orders.deliveries.findDelivery({
-    orderDeliveryId: order.deliveryId,
-  });
+  const orderDelivery =
+    order.deliveryId &&
+    (await modules.orders.deliveries.findDelivery({
+      orderDeliveryId: order.deliveryId,
+    }));
+
+  if (!orderDelivery) throw new OrderDeliveryNotFoundError({ orderDeliveryId: order.deliveryId });
 
   if (
     modules.orders.deliveries.normalizedStatus(orderDelivery) !== OrderDeliveryStatus.OPEN &&

package/src/mcp/tools/order/handlers/getTopCustomers.ts

@@ -74,15 +74,19 @@ export default async function getTopCustomers(context: Context, params: Params<'
   const normalizedCustomers = await Promise.all(
     topCustomers.map(async (c) => {
       const user = await modules.users.findUserById(c._id);
-      const avatar = await loaders.fileLoader.load({
-        fileId: user?.avatarId,
-      });
+      const avatar =
+        user?.avatarId &&
+        (await loaders.fileLoader.load({
+          fileId: user?.avatarId,
+        }));
       return {
         userId: c._id?.toString?.() ?? null,
-        user: {
-          ...user,
-          avatar,
-        },
+        user: avatar
+          ? {
+              ...user,
+              avatar,
+            }
+          : null,
         currencyCode: c?.currencyCode || null,
         totalSpent: c?.totalSpent,
         orderCount: c?.orderCount,