@unchainedshop/api 4.0.0-rc.4 → 4.0.0-rc.6

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

@@ -6,12 +6,16 @@ import { getNormalizedAssortmentDetails } from '../../utils/getNormalizedAssortm
 import { getNormalizedFilterDetails } from '../../utils/getNormalizedFilterDetails.js';
 
 export const AddAssortmentFilterSchema = {
-  assortmentId: z.string().min(1).describe('ID of the assortment'),
-  filterId: z.string().min(1).describe('ID of the filter to add'),
+  assortmentId: z.string().min(1).describe('ID of the assortment to which the filter will be added.'),
+
+  filterId: z.string().min(1).describe('ID of the filter being added to the assortment.'),
+
   tags: z
     .array(z.string().regex(/^[a-z0-9-_]+$/))
     .optional()
-    .describe('Optional lowercase tags'),
+    .describe(
+      'Optional array of lowercase tags (letters, numbers, hyphens, underscores). Used to label or categorize the filter connection.',
+    ),
 };
 
 export const AddAssortmentFilterZodSchema = z.object(AddAssortmentFilterSchema);
@@ -23,7 +27,7 @@ export async function addAssortmentFilterHandler(context: Context, params: AddAs
   const { modules, userId } = context;
 
   try {
-    log('handler addAssortmentFilter', { userId, assortmentId, filterId, tags });
+    log('handler addAssortmentFilterHandler', { userId, params });
     const assortment = await getNormalizedAssortmentDetails({ assortmentId }, context);
     if (!assortment) throw new AssortmentNotFoundError({ assortmentId });
     const filter = await getNormalizedFilterDetails(filterId, context);

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

@@ -5,9 +5,18 @@ import { getNormalizedAssortmentDetails } from '../../utils/getNormalizedAssortm
 import { AssortmentNotFoundError } from '../../../errors.js';
 
 export const AddAssortmentLinkSchema = {
-  parentAssortmentId: z.string().min(1).describe('ID of the parent assortment'),
-  childAssortmentId: z.string().min(1).describe('ID of the child assortment'),
-  tags: z.array(z.string().min(1)).default([]).describe('Tags for the link'),
+  parentAssortmentId: z
+    .string()
+    .min(1)
+    .describe('ID of the parent assortment (the container or grouping assortment).'),
+  childAssortmentId: z
+    .string()
+    .min(1)
+    .describe('ID of the child assortment (the linked or nested assortment).'),
+  tags: z
+    .array(z.string().min(1))
+    .default([])
+    .describe('Optional tags to label or categorize this link.'),
 };
 
 export const AddAssortmentLinkZodSchema = z.object(AddAssortmentLinkSchema);
@@ -19,11 +28,9 @@ export async function addAssortmentLinkHandler(context: Context, params: AddAsso
   const { modules, userId } = context;
 
   try {
-    log('handler addAssortmentLink', {
+    log('handler addAssortmentLinkHandler', {
       userId,
-      parentAssortmentId,
-      childAssortmentId,
-      tags,
+      params,
     });
     const parent = await getNormalizedAssortmentDetails({ assortmentId: parentAssortmentId }, context);
     if (!parent)

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

@@ -2,14 +2,15 @@ import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { log } from '@unchainedshop/logger';
 import { FileNotFoundError, FileUploadExpiredError } from '../../../errors.js';
+import normalizeMediaUrl from '../../utils/normalizeMediaUrl.js';
 
 export const AddAssortmentMediaUploadSchema = {
   mediaName: z
     .string()
     .min(1)
-    .describe('Name of the media file (e.g. "image.png") use random name if not provided'),
-  assortmentId: z.string().min(1).describe('ID of the assortment to link media to'),
-  url: z.string().describe('Anonymously fetchable URL of the source media, can be a data URL too'),
+    .describe('Name of the media file (e.g., "image.png"). A random name will be used if not provided.'),
+  assortmentId: z.string().min(1).describe('ID of the assortment to link the media to.'),
+  url: z.string().describe('Anonymously fetchable URL of the media file.'),
 };
 
 export const AddAssortmentMediaUploadZodSchema = z.object(AddAssortmentMediaUploadSchema);
@@ -24,7 +25,7 @@ export async function addAssortmentMediaUploadHandler(
   const { modules, services, userId } = context;
 
   try {
-    log('handler addAssortmentMediaUploadHandler', { mediaName, assortmentId, userId, url });
+    log('handler addAssortmentMediaUploadHandler', { params, userId });
     const {
       _id: fileId,
       putURL,
@@ -61,7 +62,7 @@ export async function addAssortmentMediaUploadHandler(
         {
           type: 'text' as const,
           text: JSON.stringify({
-            file: linked,
+            file: await normalizeMediaUrl([{ ...linked, mediaId: linked._id }], context),
           }),
         },
       ],

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

@@ -21,7 +21,7 @@ export async function addAssortmentProductHandler(context: Context, params: AddA
   const { modules, userId } = context;
   const { assortmentId, productId, tags } = params;
   try {
-    log('mutation addAssortmentProduct', { userId, params });
+    log('mutation addAssortmentProductHandler', { userId, params });
     const assortment = await getNormalizedAssortmentDetails({ assortmentId }, context);
     if (!assortment)
       throw new AssortmentNotFoundError({

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

@@ -4,12 +4,16 @@ import { log } from '@unchainedshop/logger';
 import { getNormalizedAssortmentDetails } from '../../utils/getNormalizedAssortmentDetails.js';
 
 export const AssortmentChildrenSchema = {
-  assortmentId: z.string().min(1).optional().describe('ID of the assortment to fetch'),
+  assortmentId: z
+    .string()
+    .min(1)
+    .optional()
+    .describe('ID of the assortment to fetch children for (optional: fetch root-level if omitted)'),
   includeInactive: z
     .boolean()
     .optional()
     .default(false)
-    .describe('Whether to include inactive assortments'),
+    .describe('Whether to include inactive child assortments in the response'),
 };
 
 export const AssortmentChildrenZodSchema = z.object(AssortmentChildrenSchema);
@@ -21,7 +25,7 @@ export async function assortmentChildrenHandler(context: Context, params: Assort
   const { assortmentId, includeInactive } = params;
 
   try {
-    log('handler assortmentChildren', { userId, params });
+    log('handler assortmentChildrenHandler', { userId, params });
     const assortmentChildren = await modules.assortments.children({
       assortmentId,
       includeInactive,

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

@@ -3,7 +3,11 @@ import { Context } from '../../../context.js';
 import { log } from '@unchainedshop/logger';
 
 export const AssortmentFiltersSchema = {
-  assortmentId: z.string().min(1).optional().describe('ID of the assortment to fetch'),
+  assortmentId: z
+    .string()
+    .min(1)
+    .optional()
+    .describe('ID of the assortment to fetch filters for (optional)'),
 };
 
 export const AssortmentFiltersZodSchema = z.object(AssortmentFiltersSchema);
@@ -15,7 +19,7 @@ export async function assortmentFiltersHandler(context: Context, params: Assortm
   const { assortmentId } = params;
 
   try {
-    log('handler assortmentFilters', { userId, params });
+    log('handler assortmentFiltersHandler', { userId, params });
     const assortmentFilters = await modules.assortments.filters.findFilters(
       {
         assortmentId,

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

@@ -21,7 +21,7 @@ export async function assortmentHandler(context: Context, params: AssortmentPara
   const { assortmentId, slug } = params;
 
   try {
-    log('handler assortment', { userId, params });
+    log('handler assortmentHandler', { userId, params });
 
     const assortment = await getNormalizedAssortmentDetails(
       {

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

@@ -4,7 +4,11 @@ import { log } from '@unchainedshop/logger';
 import { getNormalizedAssortmentDetails } from '../../utils/getNormalizedAssortmentDetails.js';
 
 export const AssortmentLinksSchema = {
-  assortmentId: z.string().min(1).optional().describe('ID of the assortment to fetch'),
+  assortmentId: z
+    .string()
+    .min(1)
+    .optional()
+    .describe('ID of the assortment to fetch links for (optional).'),
 };
 
 export const AssortmentLinksZodSchema = z.object(AssortmentLinksSchema);
@@ -16,7 +20,7 @@ export async function assortmentLinksHandler(context: Context, params: Assortmen
   const { assortmentId } = params;
 
   try {
-    log('handler assortmentLinks', { userId, params });
+    log('handler assortmentLinksHandler', { userId, params });
     const assortmentLinks = await loaders.assortmentLinksLoader.load({
       assortmentId,
     });

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

@@ -0,0 +1,57 @@
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { z } from 'zod';
+import normalizeMediaUrl from '../../utils/normalizeMediaUrl.js';
+
+export const AssortmentMediaSchema = {
+  assortmentId: z.string().min(1).describe('ID of the Assortment to retrieve media for'),
+  limit: z.number().int().min(1).max(100).default(10).describe('Number of media items to return'),
+  offset: z.number().int().min(0).default(0).describe('Pagination offset'),
+  tags: z.array(z.string().min(1)).optional().describe('Filter media by lowercase tags'),
+};
+
+export const AssortmentMediaZodSchema = z
+  .object(AssortmentMediaSchema)
+  .describe(
+    'Retrieve media assets associated with a assortment, optionally filtered by tags and paginated.',
+  );
+
+export type assortmentMediaParams = z.infer<typeof AssortmentMediaZodSchema>;
+
+export async function assortmentMediaHandler(context: Context, params: assortmentMediaParams) {
+  const { assortmentId, limit, offset, tags } = params;
+  const { modules, loaders, userId } = context;
+
+  try {
+    log('handler assortmentMediaHandler', { userId, params });
+    let media = [];
+    if (offset || tags) {
+      media = await modules.assortments.media.findAssortmentMedias({
+        assortmentId,
+        ...params,
+      });
+    } else {
+      media = (await loaders.assortmentMediasLoader.load({ assortmentId })).slice(
+        offset,
+        offset + limit,
+      );
+    }
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ media: await normalizeMediaUrl(media, context) }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error retrieving assortment media: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -4,12 +4,16 @@ import { log } from '@unchainedshop/logger';
 import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
 
 export const AssortmentProductsSchema = {
-  assortmentId: z.string().min(1).optional().describe('ID of the assortment to fetch'),
+  assortmentId: z
+    .string()
+    .min(1)
+    .optional()
+    .describe('ID of the assortment to fetch products for (optional).'),
   includeInactive: z
     .boolean()
     .optional()
     .default(false)
-    .describe('Whether to include inactive assortments'),
+    .describe('Whether to include inactive products in the assortment.'),
 };
 
 export const AssortmentProductsZodSchema = z.object(AssortmentProductsSchema);
@@ -21,7 +25,7 @@ export async function assortmentProductsHandler(context: Context, params: Assort
   const { assortmentId } = params;
 
   try {
-    log('handler assortmentProducts', { userId, params });
+    log('handler assortmentProductsHandler', { userId, params });
     const assortmentProducts = await modules.assortments.products.findAssortmentProducts(
       {
         assortmentId,

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

@@ -28,7 +28,7 @@ export async function assortmentsCountHandler(context: Context, params: Assortme
   const { modules, userId } = context;
 
   try {
-    log('handler assortmentsCount', { userId, params });
+    log('handler assortmentsCountHandler', { userId, params });
 
     const count = await modules.assortments.count(params);
 

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

@@ -5,7 +5,7 @@ import { getNormalizedAssortmentDetails } from '../../utils/getNormalizedAssortm
 
 const SortDirectionEnum = z.enum(['ASC', 'DESC']);
 
-export const SortOptionInputSchema = z.object({
+const SortOptionInputSchema = z.object({
   key: z.string().min(1).describe('Field to sort by'),
   value: SortDirectionEnum.describe('Sort direction: ASC or DESC'),
 });
@@ -39,7 +39,7 @@ export async function assortmentsHandler(context: Context, params: AssortmentsPa
   const { modules, userId } = context;
 
   try {
-    log('handler assortments', { userId, params });
+    log('handler assortmentsHandler', { userId, params });
 
     const assortments = await modules.assortments.findAssortments(params as any);
     const normalizedAssortments = await Promise.all(

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

@@ -37,7 +37,7 @@ export async function createAssortmentHandler(context: Context, params: CreateAs
   const { assortment, texts } = params;
 
   try {
-    log('handler createAssortment', { userId, params });
+    log('handler createAssortmentHandler', { userId, params });
 
     const newAssortment = await modules.assortments.create(assortment as any);
 

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

@@ -0,0 +1,281 @@
+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';
+
+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),
+  );
+};

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

@@ -19,7 +19,7 @@ export async function removeAssortmentFilterHandler(
   const { modules, userId } = context;
 
   try {
-    log('handler removeAssortmentFilter', { userId, assortmentFilterId });
+    log('handler removeAssortmentFilterHandler', { userId, params });
 
     const assortmentFilter = await modules.assortments.filters.findFilter({
       assortmentFilterId,

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

@@ -16,7 +16,7 @@ export async function removeAssortmentHandler(context: Context, params: RemoveAs
   const { assortmentId } = params;
 
   try {
-    log('handler removeAssortment', { userId, assortmentId });
+    log('handler removeAssortmentHandler', { userId, params });
 
     const assortment = await getNormalizedAssortmentDetails({ assortmentId }, context);
     if (!assortment) throw new AssortmentNotFoundError({ assortmentId });

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

@@ -16,7 +16,7 @@ export async function removeAssortmentLinkHandler(context: Context, params: Remo
   const { modules, userId } = context;
 
   try {
-    log(`handler removeAssortmentLink: ${assortmentLinkId}`, { userId });
+    log(`handler removeAssortmentLinkHandler`, { userId, params });
 
     const assortmentLink = await modules.assortments.links.findLink({
       assortmentLinkId,

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

@@ -4,7 +4,10 @@ import { log } from '@unchainedshop/logger';
 import { AssortmentMediaNotFoundError } from '../../../errors.js';
 
 export const RemoveAssortmentMediaSchema = {
-  assortmentMediaId: z.string().min(1).describe('ID of the assortment media to remove'),
+  assortmentMediaId: z
+    .string()
+    .min(1)
+    .describe('Unique ID of the media asset to remove from the assortment.'),
 };
 
 export const RemoveAssortmentMediaZodSchema = z.object(RemoveAssortmentMediaSchema);
@@ -19,7 +22,7 @@ export async function removeAssortmentMediaHandler(
   const { modules, userId } = context;
 
   try {
-    log(`handler removeAssortmentMedia: ${assortmentMediaId}`, { userId });
+    log(`handler removeAssortmentMediaHandler`, { userId, params });
 
     const assortmentMedia = await modules.assortments.media.findAssortmentMedia({
       assortmentMediaId,
@@ -33,7 +36,9 @@ export async function removeAssortmentMediaHandler(
       content: [
         {
           type: 'text' as const,
-          text: JSON.stringify({ assortmentMedia }),
+          text: JSON.stringify({
+            success: true,
+          }),
         },
       ],
     };