@unchainedshop/api 4.0.0-rc.2 → 4.0.0-rc.21

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/assortmentManagement.ts

@@ -0,0 +1,34 @@
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import {
+  actionValidators,
+  AssortmentManagementSchema,
+  AssortmentManagementZodSchema,
+  AssortmentManagementParams,
+  ActionName,
+} from './schemas.js';
+import actionHandlers from './handlers/index.js';
+import { createMcpResponse, createMcpErrorResponse } from '../../utils/sharedSchemas.js';
+
+export { AssortmentManagementSchema, AssortmentManagementZodSchema, AssortmentManagementParams };
+
+export async function assortmentManagement(context: Context, params: AssortmentManagementParams) {
+  const { action, ...actionParams } = params;
+  log('MCP assortmentManagement', { userId: context.userId, params });
+
+  try {
+    if (!(action in actionHandlers)) {
+      throw new Error(`Unknown action: ${action}`);
+    }
+
+    const parsedParams = actionValidators[action as ActionName].parse(actionParams);
+    const data = await actionHandlers[action as ActionName](context, parsedParams as never);
+
+    return createMcpResponse({
+      action,
+      data,
+    });
+  } catch (error) {
+    return createMcpErrorResponse(action, error);
+  }
+}

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

@@ -0,0 +1,23 @@
+import { Context } from '../../../../context.js';
+import { AssortmentNotFoundError } from '../../../../errors.js';
+import { getNormalizedAssortmentDetails } from '../../../utils/getNormalizedAssortmentDetails.js';
+import { Params } from '../schemas.js';
+
+export default async function addAssortmentFilter(context: Context, params: Params<'ADD_FILTER'>) {
+  const { modules } = context;
+  const { assortmentId, filterId, tags } = params;
+
+  const assortment = await modules.assortments.findAssortment({ assortmentId });
+  if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
+
+  const filter = await modules.filters.findFilter({ filterId });
+  if (!filter) throw new Error(`Filter not found: ${filterId}`);
+
+  await modules.assortments.filters.create({
+    assortmentId,
+    filterId,
+    tags,
+  } as any);
+
+  return { assortment: await getNormalizedAssortmentDetails({ assortmentId }, context) };
+}

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

@@ -0,0 +1,34 @@
+import { Context } from '../../../../context.js';
+import { AssortmentNotFoundError, CyclicAssortmentLinkNotSupportedError } from '../../../../errors.js';
+import { getNormalizedAssortmentDetails } from '../../../utils/getNormalizedAssortmentDetails.js';
+import { Params } from '../schemas.js';
+
+export default async function addAssortmentLink(context: Context, params: Params<'ADD_LINK'>) {
+  const { modules } = context;
+  const { parentAssortmentId, childAssortmentId, tags } = params;
+
+  const parentAssortment = await modules.assortments.findAssortment({
+    assortmentId: parentAssortmentId,
+  });
+  if (!parentAssortment) throw new AssortmentNotFoundError({ assortmentId: parentAssortmentId });
+
+  const childAssortment = await modules.assortments.findAssortment({
+    assortmentId: childAssortmentId,
+  });
+  if (!childAssortment) throw new Error(`Child assortment not found: ${childAssortmentId}`);
+
+  try {
+    await modules.assortments.links.create({
+      parentAssortmentId,
+      childAssortmentId,
+      tags,
+    } as any);
+    return {
+      assortment: await getNormalizedAssortmentDetails({ assortmentId: parentAssortmentId }, context),
+    };
+  } catch (e) {
+    if (e?.message === 'CyclicGraphNotSupported')
+      throw new CyclicAssortmentLinkNotSupportedError({ parentAssortmentId, childAssortmentId });
+    throw e;
+  }
+}

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

@@ -0,0 +1,20 @@
+import { Context } from '../../../../context.js';
+import { AssortmentNotFoundError } from '../../../../errors.js';
+import { getNormalizedAssortmentDetails } from '../../../utils/getNormalizedAssortmentDetails.js';
+import { Params } from '../schemas.js';
+
+export default async function addAssortmentMedia(context: Context, params: Params<'ADD_MEDIA'>) {
+  const { modules } = context;
+  const { assortmentId, mediaId, tags } = params;
+
+  const assortment = await modules.assortments.findAssortment({ assortmentId });
+  if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
+
+  await modules.assortments.media.create({
+    assortmentId,
+    mediaId,
+    tags,
+  } as any);
+
+  return { assortment: await getNormalizedAssortmentDetails({ assortmentId }, context) };
+}

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

@@ -0,0 +1,23 @@
+import { Context } from '../../../../context.js';
+import { AssortmentNotFoundError, ProductNotFoundError } from '../../../../errors.js';
+import { getNormalizedAssortmentDetails } from '../../../utils/getNormalizedAssortmentDetails.js';
+import { Params } from '../schemas.js';
+
+export default async function addAssortmentProduct(context: Context, params: Params<'ADD_PRODUCT'>) {
+  const { modules } = context;
+  const { assortmentId, productId, tags } = params;
+
+  const assortment = await modules.assortments.findAssortment({ assortmentId });
+  if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
+
+  const product = await modules.products.findProduct({ productId });
+  if (!product) throw new ProductNotFoundError({ productId });
+
+  await modules.assortments.products.create({
+    assortmentId,
+    productId,
+    tags,
+  } as any);
+
+  return { assortment: await getNormalizedAssortmentDetails({ assortmentId }, context) };
+}

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

@@ -0,0 +1,16 @@
+import { Context } from '../../../../context.js';
+import { Params } from '../schemas.js';
+
+export default async function countAssortments(context: Context, params: Params<'COUNT'>) {
+  const { modules } = context;
+  const { tags, slugs, queryString, includeInactive = false, includeLeaves = false } = params;
+
+  const count = await modules.assortments.count({
+    tags,
+    slugs,
+    queryString,
+    includeInactive,
+    includeLeaves,
+  });
+  return { count };
+}

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

@@ -0,0 +1,18 @@
+import { Context } from '../../../../context.js';
+import { Assortment, AssortmentText } from '@unchainedshop/core-assortments';
+import { getNormalizedAssortmentDetails } from '../../../utils/getNormalizedAssortmentDetails.js';
+import { Params } from '../schemas.js';
+
+export default async function createAssortment(context: Context, params: Params<'CREATE'>) {
+  const { modules } = context;
+  const { assortment, texts } = params;
+
+  const newAssortment = await modules.assortments.create(assortment as Assortment);
+
+  if (texts && texts.length > 0)
+    await modules.assortments.texts.updateTexts(newAssortment._id, texts as unknown as AssortmentText[]);
+
+  return {
+    assortment: await getNormalizedAssortmentDetails({ assortmentId: newAssortment._id }, context),
+  };
+}

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

@@ -0,0 +1,23 @@
+import { Context } from '../../../../context.js';
+import { AssortmentNotFoundError } from '../../../../errors.js';
+import { getNormalizedAssortmentDetails } from '../../../utils/getNormalizedAssortmentDetails.js';
+import { Params } from '../schemas.js';
+
+export default async function getAssortment(context: Context, params: Params<'GET'>) {
+  const { modules } = context;
+  const { assortmentId, slug } = params;
+
+  let query: any = {};
+  if (assortmentId) query = { assortmentId };
+  else if (slug) query = { slug };
+  else throw new Error('Either assortmentId or slug must be provided');
+
+  const assortment = await modules.assortments.findAssortment(query);
+  if (!assortment) throw new AssortmentNotFoundError(query);
+
+  const assortment_details = await getNormalizedAssortmentDetails(
+    { assortmentId: assortment._id },
+    context,
+  );
+  return { assortment: assortment_details };
+}

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

@@ -0,0 +1,22 @@
+import { Context } from '../../../../context.js';
+import { AssortmentNotFoundError } from '../../../../errors.js';
+import { getNormalizedAssortmentDetails } from '../../../utils/getNormalizedAssortmentDetails.js';
+import { Params } from '../schemas.js';
+
+export default async function getAssortmentChildren(context: Context, params: Params<'GET_CHILDREN'>) {
+  const { modules } = context;
+  const { assortmentId, includeInactive = false } = params;
+
+  const assortment = await getNormalizedAssortmentDetails({ assortmentId }, context);
+  if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
+
+  const children = await modules.assortments.children({ assortmentId, includeInactive });
+
+  const children_normalized = await Promise.all(
+    children?.map(async (link) => ({
+      ...(await getNormalizedAssortmentDetails({ assortmentId: link?._id }, context)),
+      ...link,
+    })) || [],
+  );
+  return { assortment, children: children_normalized };
+}

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

@@ -0,0 +1,25 @@
+import { Context } from '../../../../context.js';
+import { AssortmentNotFoundError } from '../../../../errors.js';
+import { getNormalizedAssortmentDetails } from '../../../utils/getNormalizedAssortmentDetails.js';
+import { getNormalizedFilterDetails } from '../../../utils/getNormalizedFilterDetails.js';
+import { Params } from '../schemas.js';
+
+export default async function getAssortmentFilters(context: Context, params: Params<'GET_FILTERS'>) {
+  const { modules } = context;
+  const { assortmentId } = params;
+
+  const assortment = await getNormalizedAssortmentDetails({ assortmentId }, context);
+  if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
+
+  const filters = await modules.assortments.filters.findFilters(
+    { assortmentId },
+    { sort: { sortKey: 1 } },
+  );
+  const filters_normalized = await Promise.all(
+    filters?.map(async ({ filterId, ...rest }) => ({
+      ...(await getNormalizedFilterDetails(filterId, context)),
+      ...rest,
+    })) || [],
+  );
+  return { assortment, filters: filters_normalized };
+}

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

@@ -0,0 +1,25 @@
+import { Context } from '../../../../context.js';
+import { AssortmentNotFoundError } from '../../../../errors.js';
+import { getNormalizedAssortmentDetails } from '../../../utils/getNormalizedAssortmentDetails.js';
+import { Params } from '../schemas.js';
+
+export default async function getAssortmentLinks(context: Context, params: Params<'GET_LINKS'>) {
+  const { loaders } = context;
+  const { assortmentId } = params;
+
+  const assortment = await getNormalizedAssortmentDetails({ assortmentId }, context);
+  if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
+
+  const assortmentLinks = await loaders.assortmentLinksLoader.load({
+    assortmentId,
+  });
+  const links = await Promise.all(
+    assortmentLinks
+      ?.filter((a) => a?.childAssortmentId !== assortment._id)
+      ?.map(async (link) => ({
+        ...(await getNormalizedAssortmentDetails({ assortmentId: link?.childAssortmentId }, context)),
+        ...link,
+      })) || [],
+  );
+  return { assortment, links };
+}

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

@@ -0,0 +1,27 @@
+import { Context } from '../../../../context.js';
+import { AssortmentNotFoundError } from '../../../../errors.js';
+import { getNormalizedAssortmentDetails } from '../../../utils/getNormalizedAssortmentDetails.js';
+import normalizeMediaUrl from '../../../utils/normalizeMediaUrl.js';
+import { Params } from '../schemas.js';
+
+export default async function getAssortmentMedia(context: Context, params: Params<'GET_MEDIA'>) {
+  const { modules, loaders } = context;
+  const { assortmentId, tags, limit = 50, offset = 0 } = params;
+
+  const assortment = await getNormalizedAssortmentDetails({ assortmentId }, context);
+  if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
+
+  let media;
+  if (offset || tags) {
+    media = await modules.assortments.media.findAssortmentMedias({
+      assortmentId,
+      limit,
+      offset,
+      tags,
+    });
+  } else {
+    media = (await loaders.assortmentMediasLoader.load({ assortmentId })).slice(offset, offset + limit);
+  }
+  const media_normalized = await normalizeMediaUrl(media, context);
+  return { assortment, media: media_normalized };
+}

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

@@ -0,0 +1,17 @@
+import { Context } from '../../../../context.js';
+import { AssortmentMediaNotFoundError } from '../../../../errors.js';
+import { Params } from '../schemas.js';
+
+export default async function getAssortmentMediaTexts(
+  context: Context,
+  params: Params<'GET_MEDIA_TEXTS'>,
+) {
+  const { modules } = context;
+  const { assortmentMediaId } = params;
+
+  const media = await modules.assortments.media.findAssortmentMedia({ assortmentMediaId });
+  if (!media) throw new AssortmentMediaNotFoundError({ assortmentMediaId });
+
+  const texts = await modules.assortments.media.texts.findMediaTexts({ assortmentMediaId });
+  return { texts };
+}

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

@@ -0,0 +1,26 @@
+import { Context } from '../../../../context.js';
+import { AssortmentNotFoundError } from '../../../../errors.js';
+import { getNormalizedAssortmentDetails } from '../../../utils/getNormalizedAssortmentDetails.js';
+import { getNormalizedProductDetails } from '../../../utils/getNormalizedProductDetails.js';
+import { Params } from '../schemas.js';
+
+export default async function getAssortmentProducts(context: Context, params: Params<'GET_PRODUCTS'>) {
+  const { modules } = context;
+  const { assortmentId } = params;
+
+  const assortment = await getNormalizedAssortmentDetails({ assortmentId }, context);
+  if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
+
+  const assortmentProducts = await modules.assortments.products.findAssortmentProducts(
+    { assortmentId },
+    { sort: { sortKey: 1 } },
+  );
+
+  const products = await Promise.all(
+    assortmentProducts?.map(async ({ productId, ...rest }) => ({
+      ...(await getNormalizedProductDetails(productId, context)),
+      ...rest,
+    })) || [],
+  );
+  return { assortment, products };
+}

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

@@ -0,0 +1,14 @@
+import { Context } from '../../../../context.js';
+import { AssortmentNotFoundError } from '../../../../errors.js';
+import { Params } from '../schemas.js';
+
+export default async function getAssortmentTexts(context: Context, params: Params<'GET_TEXTS'>) {
+  const { modules } = context;
+  const { assortmentId } = params;
+
+  const assortment = await modules.assortments.findAssortment({ assortmentId });
+  if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
+
+  const texts = await modules.assortments.texts.findTexts({ assortmentId });
+  return { texts };
+}

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

@@ -0,0 +1,61 @@
+import createAssortment from './createAssortment.js';
+import updateAssortment from './updateAssortment.js';
+import removeAssortment from './removeAssortment.js';
+import getAssortment from './getAssortment.js';
+import listAssortments from './listAssortments.js';
+import countAssortments from './countAssortments.js';
+import updateAssortmentStatus from './updateAssortmentStatus.js';
+import addAssortmentMedia from './addAssortmentMedia.js';
+import removeAssortmentMedia from './removeAssortmentMedia.js';
+import reorderAssortmentMedia from './reorderAssortmentMedia.js';
+import getAssortmentMedia from './getAssortmentMedia.js';
+import updateAssortmentMediaTexts from './updateAssortmentMediaTexts.js';
+import addAssortmentProduct from './addAssortmentProduct.js';
+import removeAssortmentProduct from './removeAssortmentProduct.js';
+import getAssortmentProducts from './getAssortmentProducts.js';
+import reorderAssortmentProducts from './reorderAssortmentProducts.js';
+import addAssortmentFilter from './addAssortmentFilter.js';
+import removeAssortmentFilter from './removeAssortmentFilter.js';
+import getAssortmentFilters from './getAssortmentFilters.js';
+import reorderAssortmentFilters from './reorderAssortmentFilters.js';
+import addAssortmentLink from './addAssortmentLink.js';
+import removeAssortmentLink from './removeAssortmentLink.js';
+import getAssortmentLinks from './getAssortmentLinks.js';
+import reorderAssortmentLinks from './reorderAssortmentLinks.js';
+import getAssortmentChildren from './getAssortmentChildren.js';
+import setAssortmentBase from './setAssortmentBase.js';
+import searchAssortmentProducts from './searchAssortmentProducts.js';
+import getAssortmentTexts from './getAssortmentTexts.js';
+import getAssortmentMediaTexts from './getAssortmentMediaTexts.js';
+
+export default {
+  CREATE: createAssortment,
+  UPDATE: updateAssortment,
+  REMOVE: removeAssortment,
+  GET: getAssortment,
+  LIST: listAssortments,
+  COUNT: countAssortments,
+  UPDATE_STATUS: updateAssortmentStatus,
+  ADD_MEDIA: addAssortmentMedia,
+  REMOVE_MEDIA: removeAssortmentMedia,
+  REORDER_MEDIA: reorderAssortmentMedia,
+  GET_MEDIA: getAssortmentMedia,
+  UPDATE_MEDIA_TEXTS: updateAssortmentMediaTexts,
+  ADD_PRODUCT: addAssortmentProduct,
+  REMOVE_PRODUCT: removeAssortmentProduct,
+  GET_PRODUCTS: getAssortmentProducts,
+  REORDER_PRODUCTS: reorderAssortmentProducts,
+  ADD_FILTER: addAssortmentFilter,
+  REMOVE_FILTER: removeAssortmentFilter,
+  GET_FILTERS: getAssortmentFilters,
+  REORDER_FILTERS: reorderAssortmentFilters,
+  ADD_LINK: addAssortmentLink,
+  REMOVE_LINK: removeAssortmentLink,
+  GET_LINKS: getAssortmentLinks,
+  REORDER_LINKS: reorderAssortmentLinks,
+  GET_CHILDREN: getAssortmentChildren,
+  SET_BASE: setAssortmentBase,
+  SEARCH_PRODUCTS: searchAssortmentProducts,
+  GET_TEXTS: getAssortmentTexts,
+  GET_MEDIA_TEXTS: getAssortmentMediaTexts,
+};

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

@@ -0,0 +1,36 @@
+import { Context } from '../../../../context.js';
+import { getNormalizedAssortmentDetails } from '../../../utils/getNormalizedAssortmentDetails.js';
+import { Params } from '../schemas.js';
+
+export default async function listAssortments(context: Context, params: Params<'LIST'>) {
+  const { modules } = context;
+  const {
+    limit = 50,
+    offset = 0,
+    tags,
+    slugs,
+    queryString,
+    includeInactive = false,
+    includeLeaves = false,
+    sort,
+  } = params;
+
+  const sortOptions = sort?.map((s) => ({ key: s.key, value: s.value as any })) || undefined;
+
+  const assortments = await modules.assortments.findAssortments({
+    limit,
+    offset,
+    tags,
+    slugs,
+    queryString,
+    includeInactive,
+    includeLeaves,
+    sort: sortOptions,
+  });
+  const assortments_normalized = await Promise.all(
+    assortments?.map(
+      async ({ _id }) => await getNormalizedAssortmentDetails({ assortmentId: _id }, context),
+    ) || [],
+  );
+  return { assortments: assortments_normalized };
+}

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

@@ -0,0 +1,14 @@
+import { Context } from '../../../../context.js';
+import { AssortmentNotFoundError } from '../../../../errors.js';
+import { Params } from '../schemas.js';
+
+export default async function removeAssortment(context: Context, params: Params<'REMOVE'>) {
+  const { modules } = context;
+  const { assortmentId } = params;
+
+  const assortment = await modules.assortments.findAssortment({ assortmentId });
+  if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
+
+  const deletedAssortment = await modules.assortments.delete(assortmentId);
+  return { success: Boolean(deletedAssortment) };
+}

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

@@ -0,0 +1,10 @@
+import { Context } from '../../../../context.js';
+import { Params } from '../schemas.js';
+
+export default async function removeAssortmentFilter(context: Context, params: Params<'REMOVE_FILTER'>) {
+  const { modules } = context;
+  const { assortmentFilterId } = params;
+
+  const deletedAssortmentFilter = await modules.assortments.filters.delete(assortmentFilterId);
+  return { success: Boolean(deletedAssortmentFilter) };
+}

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

@@ -0,0 +1,14 @@
+import { Context } from '../../../../context.js';
+
+import { Params } from '../schemas.js';
+
+export default async function removeAssortmentLink(context: Context, params: Params<'REMOVE_LINK'>) {
+  const { modules } = context;
+  const { assortmentLinkId } = params;
+
+  const existing = await modules.assortments.links.findLink({ assortmentLinkId });
+  if (!existing) throw new Error(`Assortment link not found: ${assortmentLinkId}`);
+
+  const deletedAssortmentLink = await modules.assortments.links.delete(assortmentLinkId);
+  return { success: Boolean(deletedAssortmentLink) };
+}

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

@@ -0,0 +1,10 @@
+import { Context } from '../../../../context.js';
+
+import { Params } from '../schemas.js';
+
+export default async function removeAssortmentMedia(context: Context, params: Params<'REMOVE_MEDIA'>) {
+  const { modules } = context;
+  const { mediaId } = params;
+  await modules.assortments.media.delete(mediaId);
+  return { success: true };
+}

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

@@ -0,0 +1,13 @@
+import { Context } from '../../../../context.js';
+import { Params } from '../schemas.js';
+
+export default async function removeAssortmentProduct(
+  context: Context,
+  params: Params<'REMOVE_PRODUCT'>,
+) {
+  const { modules } = context;
+  const { assortmentProductId } = params;
+
+  const deletedAssortmentProduct = await modules.assortments.products.delete(assortmentProductId);
+  return { success: Boolean(deletedAssortmentProduct) };
+}