@unchainedshop/api 4.0.0-rc.15 → 4.0.0-rc.17

package/src/fastify/tempUploadHandler.ts

@@ -36,16 +36,14 @@ 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, {});
-    const body = JSON.stringify({ fileId: file._id, url, expires: expires.toISOString() });
     res.status(200);
-    res.header('Content-Length', new TextEncoder().encode(body).length);
-    res.header('Content-Type', 'application/json');
-    return res.send(body);
+    return res.send({ fileId: file._id, url, expires: expires.toISOString() });
   } catch (e) {
-    logger.error(e.message);
+    logger.error(e);
     res.status(503);
-    return res.send(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
+    return res.send({ name: e.name, code: e.code, message: e.message });
   }
 };
 

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,
+    locale: locale!,
+    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,

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

@@ -2,6 +2,7 @@ import { OrderPaymentStatus } from '@unchainedshop/core-orders';
 import { Context } from '../../../../context.js';
 import {
   OrderNotFoundError,
+  OrderPaymentNotFoundError,
   OrderWrongPaymentStatusError,
   OrderWrongStatusError,
 } from '../../../../errors.js';
@@ -19,9 +20,13 @@ export default async function payOrder(context: Context, params: Params<'PAY_ORD
     throw new OrderWrongStatusError({ status: order.status });
   }
 
-  const payment = await modules.orders.payments.findOrderPayment({
-    orderPaymentId: order.paymentId,
-  });
+  const payment =
+    order.paymentId &&
+    (await modules.orders.payments.findOrderPayment({
+      orderPaymentId: order.paymentId,
+    }));
+
+  if (!payment) throw new OrderPaymentNotFoundError({ orderPaymentId: order.paymentId });
 
   if (modules.orders.payments.normalizedStatus(payment) !== OrderPaymentStatus.OPEN) {
     throw new OrderWrongPaymentStatusError({

package/src/mcp/tools/product/handlers/addBundleItem.ts

@@ -1,38 +1,39 @@
 import { Context } from '../../../../context.js';
 import { ProductTypes } from '@unchainedshop/core-products';
-import { ProductNotFoundError, ProductWrongTypeError } from '../../../../errors.js';
+import {
+  CyclicProductBundlingNotSupportedError,
+  ProductNotFoundError,
+  ProductWrongTypeError,
+} from '../../../../errors.js';
 import { getNormalizedProductDetails } from '../../../utils/getNormalizedProductDetails.js';
 import { Params } from '../schemas.js';
 
 export default async function addBundleItem(context: Context, params: Params<'ADD_BUNDLE_ITEM'>) {
   const { modules } = context;
   const { bundleId, bundleProductId, quantity } = params;
+  const product = await modules.products.findProduct({ productId: bundleId });
+  if (!product) throw new ProductNotFoundError({ productId: bundleId });
 
-  const bundle = await modules.products.findProduct({ productId: bundleId });
-  if (!bundle) throw new ProductNotFoundError({ productId: bundleId });
-
-  if (bundle.type !== ProductTypes.BundleProduct) {
+  if (product.type !== ProductTypes.BundleProduct)
     throw new ProductWrongTypeError({
       productId: bundleId,
-      received: bundle.type,
+      received: product.type,
       required: ProductTypes.BundleProduct,
     });
-  }
 
-  const bundleProduct = await modules.products.findProduct({ productId: bundleProductId });
-  if (!bundleProduct) throw new ProductNotFoundError({ productId: bundleProductId });
+  const itemProduct = await modules.products.findProduct({ productId: bundleProductId });
+  if (!itemProduct) throw new ProductNotFoundError({ productId: bundleProductId });
+
+  if (itemProduct._id === product._id)
+    throw new CyclicProductBundlingNotSupportedError({
+      productId: itemProduct._id,
+    });
 
-  await modules.products.update(bundleId, {
-    ...bundle,
-    bundleItems: [
-      ...(bundle.bundleItems || []),
-      {
-        productId: bundleProductId,
-        quantity: quantity || 1,
-      },
-    ],
+  await modules.products.bundleItems.addBundleItem(bundleId, {
+    productId: bundleProductId,
+    quantity,
+    configuration: [],
   });
 
-  const product = await getNormalizedProductDetails(bundleId, context);
-  return { product };
+  return { product: await getNormalizedProductDetails(bundleId, context) };
 }

package/src/mcp/tools/product/handlers/addProductAssignment.ts

@@ -1,5 +1,5 @@
 import { Context } from '../../../../context.js';
-import { ProductTypes } from '@unchainedshop/core-products';
+import { ProductTypes, ProductVariation } from '@unchainedshop/core-products';
 import { ProductNotFoundError, ProductWrongTypeError } from '../../../../errors.js';
 import { getNormalizedProductDetails } from '../../../utils/getNormalizedProductDetails.js';
 import { Params } from '../schemas.js';
@@ -21,15 +21,15 @@ export default async function addProductAssignment(context: Context, params: Par
 
   // Extract variation matrix and validate vectors
   const variations = await modules.products.variations.findProductVariations({ productId: proxyId });
-  const extractVariationMatrix = (variations = []) => {
+  const extractVariationMatrix = (variations: ProductVariation[] = []) => {
     const cartesianProduct = (arrays) => {
       return arrays.reduce(
         (acc, array) => acc.flatMap((item) => array.map((value) => [...item, value])),
         [[]],
       );
     };
-    const keys = variations.map((item) => item.key);
-    const options = variations.map((item) => item.options);
+    const keys = variations.map((item: any) => item.key);
+    const options = variations.map((item: any) => item.options);
     const combinations = cartesianProduct(options);
     return combinations.map((combination) =>
       combination.reduce((acc, value, index) => {

package/src/mcp/tools/product/handlers/addProductMedia.ts

@@ -1,6 +1,6 @@
 import { Context } from '../../../../context.js';
 import { ProductNotFoundError } from '../../../../errors.js';
-import normalizeMediaUrl from '../../../utils/normalizeMediaUrl.js';
+import { getNormalizedProductDetails } from '../../../utils/getNormalizedProductDetails.js';
 import { Params } from '../schemas.js';
 
 export default async function addProductMedia(context: Context, params: Params<'ADD_MEDIA'>) {
@@ -39,8 +39,7 @@ export default async function addProductMedia(context: Context, params: Params<'
   if (file.expires && new Date(file.expires).getTime() < Date.now()) {
     throw new Error(`File upload expired: ${fileId}`);
   }
-
-  const linked = await services.files.linkFile({ fileId, size, type });
-  const media = await normalizeMediaUrl([{ ...linked, mediaId: linked._id }], context);
-  return { media };
+  await services.files.linkFile({ fileId, size, type });
+  const updatedProduct = await getNormalizedProductDetails(productId, context);
+  return { product: updatedProduct };
 }