@unchainedshop/api 4.0.0-rc.11 → 4.0.0-rc.13

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 });
+
+  await modules.assortments.delete(assortmentId);
+  return { success: true };
+}

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;
+
+  await modules.assortments.filters.delete(assortmentFilterId);
+  return { success: true };
+}

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}`);
+
+  await modules.assortments.links.delete(assortmentLinkId);
+  return { success: true };
+}

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;
+
+  await modules.assortments.products.delete(assortmentProductId);
+  return { success: true };
+}

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

@@ -0,0 +1,22 @@
+import { Context } from '../../../../context.js';
+import { getNormalizedFilterDetails } from '../../../utils/getNormalizedFilterDetails.js';
+import { Params } from '../schemas.js';
+
+export default async function reorderAssortmentFilters(
+  context: Context,
+  params: Params<'REORDER_FILTERS'>,
+) {
+  const { modules } = context;
+  const { sortKeys } = params;
+
+  const reorderedFilters = await modules.assortments.filters.updateManualOrder({
+    sortKeys: sortKeys as any,
+  });
+  const filters = await Promise.all(
+    reorderedFilters?.map(async ({ filterId, ...rest }) => ({
+      ...(await getNormalizedFilterDetails(filterId, context)),
+      ...rest,
+    })) || [],
+  );
+  return { filters };
+}

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

@@ -0,0 +1,17 @@
+import { Context } from '../../../../context.js';
+import { getNormalizedAssortmentDetails } from '../../../utils/getNormalizedAssortmentDetails.js';
+import { Params } from '../schemas.js';
+
+export default async function reorderAssortmentLinks(context: Context, params: Params<'REORDER_LINKS'>) {
+  const { modules } = context;
+  const { sortKeys } = params;
+
+  const links = await modules.assortments.links.updateManualOrder({ sortKeys: sortKeys as any });
+  const normalizedAssortmentLinks = await Promise.all(
+    links?.map(async (link) => ({
+      ...(await getNormalizedAssortmentDetails({ assortmentId: link?.childAssortmentId }, context)),
+      ...link,
+    })) || [],
+  );
+  return { assortments: normalizedAssortmentLinks };
+}

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

@@ -0,0 +1,11 @@
+import { Context } from '../../../../context.js';
+import normalizeMediaUrl from '../../../utils/normalizeMediaUrl.js';
+import { Params } from '../schemas.js';
+
+export default async function reorderAssortmentMedia(context: Context, params: Params<'REORDER_LINKS'>) {
+  const { modules } = context;
+  const { sortKeys } = params;
+  const media = await modules.assortments.media.updateManualOrder({ sortKeys: sortKeys as any });
+
+  return { links: await normalizeMediaUrl(media, context) };
+}

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

@@ -0,0 +1,22 @@
+import { Context } from '../../../../context.js';
+import { getNormalizedProductDetails } from '../../../utils/getNormalizedProductDetails.js';
+import { Params } from '../schemas.js';
+
+export default async function reorderAssortmentProducts(
+  context: Context,
+  params: Params<'REORDER_PRODUCTS'>,
+) {
+  const { modules } = context;
+  const { sortKeys } = params;
+
+  const reorderedProducts = await modules.assortments.products.updateManualOrder({
+    sortKeys: sortKeys as any,
+  });
+  const products = await Promise.all(
+    reorderedProducts?.map(async ({ productId, ...rest }) => ({
+      ...(await getNormalizedProductDetails(productId, context)),
+      ...rest,
+    })) || [],
+  );
+  return { products };
+}

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

@@ -0,0 +1,48 @@
+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 searchAssortmentProducts(
+  context: Context,
+  params: Params<'SEARCH_PRODUCTS'>,
+) {
+  const { modules, services } = context;
+  const { assortmentId, queryString, limit = 50, offset = 0, includeInactive = false } = params;
+
+  const assortment = await getNormalizedAssortmentDetails({ assortmentId }, context);
+  if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
+
+  const productIds = await modules.assortments.findProductIds({
+    assortmentId,
+  });
+
+  const filterIds = await modules.assortments.filters.findFilterIds({
+    assortmentId,
+  });
+
+  const result = await services.filters.searchProducts(
+    {
+      queryString,
+      includeInactive,
+      productIds,
+      filterIds,
+    } as any,
+    {
+      locale: context.locale,
+    },
+  );
+
+  const products = await modules.products.search.findFilteredProducts({
+    limit,
+    offset,
+    productIds: result.aggregatedFilteredProductIds,
+    productSelector: result.searchConfiguration.productSelector,
+    sort: result.searchConfiguration.sortStage,
+  });
+  const products_normalized = await Promise.all(
+    products?.map(async ({ _id }) => getNormalizedProductDetails(_id, context)) || [],
+  );
+  return { assortment, products: products_normalized };
+}

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

@@ -0,0 +1,15 @@
+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 setAssortmentBase(context: Context, params: Params<'SET_BASE'>) {
+  const { modules } = context;
+  const { assortmentId } = params;
+
+  const existingAssortment = await modules.assortments.findAssortment({ assortmentId });
+  if (!existingAssortment) throw new AssortmentNotFoundError({ assortmentId });
+
+  await modules.assortments.setBase(assortmentId);
+  return { assortment: await getNormalizedAssortmentDetails({ assortmentId }, context) };
+}

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

@@ -0,0 +1,26 @@
+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 updateAssortment(context: Context, params: Params<'UPDATE'>) {
+  const { modules } = context;
+  const { assortmentId, assortment } = params;
+
+  const existingAssortment = await modules.assortments.findAssortment({ assortmentId });
+  if (!existingAssortment) throw new AssortmentNotFoundError({ assortmentId });
+
+  const updateData: any = {};
+
+  if (assortment.isRoot !== undefined) updateData.isRoot = assortment.isRoot;
+  if (assortment.isActive !== undefined) updateData.isActive = assortment.isActive;
+  if (assortment.tags !== undefined) updateData.tags = assortment.tags;
+  if (assortment.sequence !== undefined) updateData.sequence = assortment.sequence;
+  if (assortment.meta !== undefined) updateData.meta = assortment.meta;
+
+  if (Object.keys(updateData).length > 0) {
+    await modules.assortments.update(assortmentId, updateData);
+  }
+
+  return { assortment: await getNormalizedAssortmentDetails({ assortmentId }, context) };
+}

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

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

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

@@ -0,0 +1,18 @@
+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 updateAssortmentStatus(context: Context, params: Params<'UPDATE_STATUS'>) {
+  const { modules } = context;
+  const { assortmentId, statusAction } = params;
+  const assortment = await modules.assortments.findAssortment({ assortmentId });
+  if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
+
+  const updateData = {
+    isActive: statusAction === 'ACTIVATE',
+  };
+
+  await modules.assortments.update(assortmentId, updateData as any);
+  return { assortment: await getNormalizedAssortmentDetails({ assortmentId }, context) };
+}

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

@@ -1,281 +1,12 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { Context } from '../../../context.js';
-import { createAssortmentHandler, CreateAssortmentSchema } from './createAssortmentHandler.js';
-import { AddAssortmentFilterSchema, addAssortmentFilterHandler } from './addAssortmentFilterHandler.js';
-import { AddAssortmentLinkSchema, addAssortmentLinkHandler } from './addAssortmentLinkHandler.js';
-import {
-  AddAssortmentMediaUploadSchema,
-  addAssortmentMediaUploadHandler,
-} from './addAssortmentMediaUploadHandler.js';
-import {
-  AddAssortmentProductSchema,
-  addAssortmentProductHandler,
-} from './addAssortmentProductHandler.js';
-import { AssortmentChildrenSchema, assortmentChildrenHandler } from './assortmentChildrenHandler.js';
-import { AssortmentFiltersSchema, assortmentFiltersHandler } from './assortmentFiltersHandler.js';
-import { AssortmentSchema, assortmentHandler } from './assortmentHandler.js';
-import { AssortmentLinksSchema, assortmentLinksHandler } from './assortmentLinksHandler.js';
-import { AssortmentProductsSchema, assortmentProductsHandler } from './assortmentProductsHandler.js';
-import { AssortmentsCountSchema, assortmentsCountHandler } from './assortmentsCountHandler.js';
-import { AssortmentsSchema, assortmentsHandler } from './assortmentsHandler.js';
-import {
-  RemoveAssortmentFilterSchema,
-  removeAssortmentFilterHandler,
-} from './removeAssortmentFilterHandler.js';
-import { RemoveAssortmentSchema, removeAssortmentHandler } from './removeAssortmentHandler.js';
-import {
-  RemoveAssortmentLinkSchema,
-  removeAssortmentLinkHandler,
-} from './removeAssortmentLinkHandler.js';
-import {
-  RemoveAssortmentMediaSchema,
-  removeAssortmentMediaHandler,
-} from './removeAssortmentMediaHandler.js';
-import {
-  RemoveAssortmentProductSchema,
-  removeAssortmentProductHandler,
-} from './removeAssortmentProductHandler.js';
-import {
-  ReorderAssortmentFiltersSchema,
-  reorderAssortmentFiltersHandler,
-} from './reorderAssortmentFiltersHandler.js';
-import {
-  ReorderAssortmentLinksSchema,
-  reorderAssortmentLinksHandler,
-} from './reorderAssortmentLinksHandler.js';
-import {
-  ReorderAssortmentMediaSchema,
-  reorderAssortmentMediaHandler,
-} from './reorderAssortmentMediaHandler.js';
-import {
-  ReorderAssortmentProductsSchema,
-  reorderAssortmentProductsHandler,
-} from './reorderAssortmentProductsHandler.js';
-import {
-  SearchAssortmentProductSchema,
-  searchAssortmentProductHandler,
-} from './searchAssortmentProductHandler.js';
-import { SetBaseAssortmentSchema, setBaseAssortmentHandler } from './setBaseAssortmentHandler.js';
-import {
-  TranslatedAssortmentMediaTextsSchema,
-  translatedAssortmentMediaTextsHandler,
-} from './translatedAssortmentMediaTextsHandler.js';
-import {
-  TranslatedAssortmentTextsSchema,
-  translatedAssortmentTextsHandler,
-} from './translatedAssortmentTextsHandler.js';
-import { UpdateAssortmentSchema, updateAssortmentHandler } from './updateAssortmentHandler.js';
-import {
-  UpdateAssortmentMediaTextsSchema,
-  updateAssortmentMediaTextsHandler,
-} from './updateAssortmentMediaTextsHandler.js';
-import {
-  UpdateAssortmentTextsSchema,
-  updateAssortmentTextsHandler,
-} from './updateAssortmentTextsHandler.js';
-import { assortmentMediaHandler, AssortmentMediaSchema } from './assortmentMediaHandler.js';
+import { assortmentManagement, AssortmentManagementSchema } from './assortmentManagement.js';
 
 export const registerAssortmentTools = (server: McpServer, context: Context) => {
   server.tool(
-    'assortment_create',
-    'Create a new assortment with optional localized texts.',
-    CreateAssortmentSchema,
-    async (params) => createAssortmentHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_update',
-    'Update fields of an existing assortment by ID.',
-    UpdateAssortmentSchema,
-    async (params) => updateAssortmentHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_remove',
-    'Remove an assortment by ID.',
-    RemoveAssortmentSchema,
-    async (params) => removeAssortmentHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_setBase',
-    'Makes the provided assortment the base assortment and resets others to regular.',
-    SetBaseAssortmentSchema,
-    async (params) => setBaseAssortmentHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_get',
-    'Fetch details of an assortment by ID or slug.',
-    AssortmentSchema,
-    async (params) => assortmentHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_list',
-    'List assortments with filtering, pagination, and sorting options.',
-    AssortmentsSchema,
-    async (params) => assortmentsHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_count',
-    'Count assortments matching given filters.',
-    AssortmentsCountSchema,
-    async (params) => assortmentsCountHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_getChildren',
-    'Fetch child assortments for a given assortment ID (or root-level assortments if none is provided).',
-    AssortmentChildrenSchema,
-    async (params) => assortmentChildrenHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_getProducts',
-    'Fetch products for a given assortment, optionally including inactive ones.',
-    AssortmentProductsSchema,
-    async (params) => assortmentProductsHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_searchProducts',
-    'Search products within an assortment with optional filtering and pagination.',
-    SearchAssortmentProductSchema,
-    async (params) => searchAssortmentProductHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_getLinks',
-    'Fetch parent and child links for a given assortment_',
-    AssortmentLinksSchema,
-    async (params) => assortmentLinksHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_getFilters',
-    'Fetch filters associated with a specific assortment_',
-    AssortmentFiltersSchema,
-    async (params) => assortmentFiltersHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_addProduct',
-    'Add a product to an assortment with optional tags.',
-    AddAssortmentProductSchema,
-    async (params) => addAssortmentProductHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_removeProduct',
-    'Remove a product from an assortment_',
-    RemoveAssortmentProductSchema,
-    async (params) => removeAssortmentProductHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_reorderProducts',
-    'Reorder assortment products by assigning new sort keys.',
-    ReorderAssortmentProductsSchema,
-    async (params) => reorderAssortmentProductsHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_linkChild',
-    'Create a parent-child relationship between two assortments, with optional tags.',
-    AddAssortmentLinkSchema,
-    async (params) => addAssortmentLinkHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_removeLink',
-    'Remove a link between assortments by ID.',
-    RemoveAssortmentLinkSchema,
-    async (params) => removeAssortmentLinkHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_reorderLinks',
-    'Reorder assortment links by assigning new sort keys.',
-    ReorderAssortmentLinksSchema,
-    async (params) => reorderAssortmentLinksHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_reorderMedias',
-    'Reorder assortment media assets with new sorting keys; first item becomes primary media.',
-    ReorderAssortmentMediaSchema,
-    async (params) => reorderAssortmentMediaHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_addMedia',
-    'Upload and link a media asset (e.g., image or video) to an assortment_',
-    AddAssortmentMediaUploadSchema,
-    async (params) => addAssortmentMediaUploadHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_removeMedia',
-    'Remove a media asset previously attached to an assortment_',
-    RemoveAssortmentMediaSchema,
-    async (params) => removeAssortmentMediaHandler(context, params),
-  );
-
-  server.tool(
-    'assortmentMedia_updateTexts',
-    'Update localized texts for a specific assortment media asset.',
-    UpdateAssortmentMediaTextsSchema,
-    async (params) => updateAssortmentMediaTextsHandler(context, params),
-  );
-
-  server.tool(
-    'assortmentMedia_getTexts',
-    'Retrieve translated texts associated with a specific assortment media asset.',
-    TranslatedAssortmentMediaTextsSchema,
-    async (params) => translatedAssortmentMediaTextsHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_getTexts',
-    'Retrieve translated texts for a specific assortment_',
-    TranslatedAssortmentTextsSchema,
-    async (params) => translatedAssortmentTextsHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_updateTexts',
-    'Update localized texts (title, subtitle, description, slug) of an assortment for one or more locales.',
-    UpdateAssortmentTextsSchema,
-    async (params) => updateAssortmentTextsHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_addFilter',
-    'Attach a filter to a specific assortment, optionally tagging the relation.',
-    AddAssortmentFilterSchema,
-    async (params) => addAssortmentFilterHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_removeFilter',
-    'Remove a filter from an assortment_',
-    RemoveAssortmentFilterSchema,
-    async (params) => removeAssortmentFilterHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_reorderFilters',
-    'Reorder assortment filters by assigning new sort keys.',
-    ReorderAssortmentFiltersSchema,
-    async (params) => reorderAssortmentFiltersHandler(context, params),
-  );
-
-  server.tool(
-    'assortment_getMedias',
-    'Retrieve media assets associated with a assortment, optionally filtered by tags and paginated.',
-    AssortmentMediaSchema,
-    async (params) => assortmentMediaHandler(context, params),
+    '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),
   );
 };