@unchainedshop/api 4.0.0-rc.5 → 4.0.0-rc.7

package/src/errors.ts

@@ -230,6 +230,11 @@ export const CyclicAssortmentLinkNotSupportedError = createError(
   'Cyclic assortment link detected, make sure child assortment is not assigned as a parent on the assortment graph',
 );
 
+export const CyclicProductBundlingNotSupportedError = createError(
+  'CyclicBundlingNotSupportedError',
+  'Cyclic bundling detected, make sure bundled product is not the same as the bundle product itself',
+);
+
 export const EmailAlreadyExistsError = createError(
   'EmailAlreadyExists',
   'Email already exists or is invalid',
@@ -319,3 +324,8 @@ export const ImpersonatingAdminUserError = createError(
   'ImpersonatingAdminUserError',
   'Can not impersonate a admin user account',
 );
+
+export const DuplicateFilterKeyError = createError(
+  'DuplicateFilterKeyError',
+  'Key already registered for another filter',
+);

package/src/loaders/index.ts

@@ -14,6 +14,7 @@ import productLoaderBySKU from './productLoaderBySKU.js';
 import productTextLoader from './productTextLoader.js';
 import productMediaTextLoader from './productMediaTextLoader.js';
 import productMediasLoader from './productMediasLoader.js';
+import productProxiesLoader from './productProxiesLoader.js';
 import fileLoader from './fileLoader.js';
 import userLoader from './userLoader.js';
 import countryLoader from './countryLoader.js';
@@ -42,6 +43,7 @@ const loaders = (unchainedAPI: UnchainedCore) => {
     productTextLoader: productTextLoader(unchainedAPI),
     productMediaTextLoader: productMediaTextLoader(unchainedAPI),
     productMediasLoader: productMediasLoader(unchainedAPI),
+    productProxiesLoader: productProxiesLoader(unchainedAPI),
 
     fileLoader: fileLoader(unchainedAPI),
 

package/src/loaders/productProxiesLoader.ts

@@ -0,0 +1,37 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { Product } from '@unchainedshop/core-products';
+import DataLoader from 'dataloader';
+
+export default (unchainedAPI: UnchainedCore) =>
+  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({
+      includeDrafts: true,
+      productSelector: {
+        $or: [
+          {
+            'bundleItems.productId': { $in: productIds },
+          },
+          {
+            'proxy.assignments.productId': { $in: productIds },
+          },
+        ],
+      },
+    });
+
+    const productProxyMap = {};
+    for (const productProxy of productProxies) {
+      const bundleItemIds = productProxy.bundleItems?.map((item) => item.productId) || [];
+      const proxyAssignmentIds =
+        productProxy.proxy?.assignments?.map((assignment) => assignment.productId) || [];
+
+      for (const productId of [...bundleItemIds, ...proxyAssignmentIds]) {
+        if (!productProxyMap[productId]) {
+          productProxyMap[productId] = [];
+        }
+        productProxyMap[productId].push(productProxy);
+      }
+    }
+    return queries.map((q) => productProxyMap[q.productId] || []);
+  });

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

@@ -2,6 +2,7 @@ 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
@@ -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/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/index.ts

@@ -73,6 +73,7 @@ import {
   UpdateAssortmentTextsSchema,
   updateAssortmentTextsHandler,
 } from './updateAssortmentTextsHandler.js';
+import { assortmentMediaHandler, AssortmentMediaSchema } from './assortmentMediaHandler.js';
 
 export const registerAssortmentTools = (server: McpServer, context: Context) => {
   server.tool(
@@ -202,7 +203,7 @@ export const registerAssortmentTools = (server: McpServer, context: Context) =>
   );
 
   server.tool(
-    'assortment_reorderMedia',
+    'assortment_reorderMedias',
     'Reorder assortment media assets with new sorting keys; first item becomes primary media.',
     ReorderAssortmentMediaSchema,
     async (params) => reorderAssortmentMediaHandler(context, params),
@@ -270,4 +271,11 @@ export const registerAssortmentTools = (server: McpServer, context: Context) =>
     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/removeAssortmentMediaHandler.ts

@@ -36,7 +36,9 @@ export async function removeAssortmentMediaHandler(
       content: [
         {
           type: 'text' as const,
-          text: JSON.stringify({ assortmentMedia }),
+          text: JSON.stringify({
+            success: true,
+          }),
         },
       ],
     };

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

@@ -30,7 +30,7 @@ export async function reorderAssortmentMediaHandler(
   try {
     log('handler reorderAssortmentMediaHandler', { userId, params });
 
-    await modules.assortments.media.updateManualOrder({
+    const media = await modules.assortments.media.updateManualOrder({
       sortKeys,
     } as any);
 
@@ -38,7 +38,7 @@ export async function reorderAssortmentMediaHandler(
       content: [
         {
           type: 'text' as const,
-          text: JSON.stringify({ success: true }),
+          text: JSON.stringify({ media }),
         },
       ],
     };

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { log } from '@unchainedshop/logger';
+import { AssortmentMediaNotFoundError } from '../../../errors.js';
 
 export const TranslatedAssortmentMediaTextsSchema = {
   assortmentMediaId: z.string().min(1).describe('ID of the assortment media to retrieve texts for'),
@@ -22,6 +23,12 @@ export async function translatedAssortmentMediaTextsHandler(
   try {
     log('handler translatedAssortmentMediaTextsHandler', { userId, params });
 
+    const assortmentMedia = await modules.assortments.media.findAssortmentMedia({
+      assortmentMediaId,
+    });
+
+    if (!assortmentMedia) throw new AssortmentMediaNotFoundError({ assortmentMediaId });
+
     const texts = await modules.assortments.media.texts.findMediaTexts({
       assortmentMediaId,
     });
@@ -30,7 +37,7 @@ export async function translatedAssortmentMediaTextsHandler(
       content: [
         {
           type: 'text' as const,
-          text: JSON.stringify({ texts }),
+          text: JSON.stringify({ texts, assortmentId: assortmentMedia.assortmentId }),
         },
       ],
     };

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

@@ -47,7 +47,10 @@ export async function updateAssortmentMediaTextsHandler(
       content: [
         {
           type: 'text' as const,
-          text: JSON.stringify({ assortmentMediaTexts }),
+          text: JSON.stringify({
+            texts: assortmentMediaTexts,
+            assortmentId: assortmentMedia?.assortmentId,
+          }),
         },
       ],
     };

package/src/mcp/tools/product/addProductAssignmentHandler.ts

@@ -51,7 +51,9 @@ export const AssignProductVariationSchema = {
   vectors: z
     .array(ProductAssignmentVectorSchema)
     .min(1)
-    .describe('Combination of attributes uniquely identifying the variant'),
+    .describe(
+      'Provide one option for **each** variation of the parent product (e.g., Color and Size). if it is not complete request the user to add all options or offer to create it. Do not call this tool unless all variation options have been selected. Otherwise, this will fail.',
+    ),
 };
 
 export const AddProductAssignmentZodSchema = z.object(AssignProductVariationSchema);

package/src/mcp/tools/product/addProductBundleItemHandler.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { ProductNotFoundError, ProductWrongTypeError } from '../../../errors.js';
+import { log } from '@unchainedshop/logger';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { ProductTypes } from '@unchainedshop/core-products';
+
+const AddProductBundleItemInputSchema = z.object({
+  productId: z.string().min(1),
+  quantity: z.number().int().min(1),
+});
+
+export const AddProductBundleItemSchema = {
+  productId: z.string().min(1).describe('ID of the BUNDLE_PRODUCT to which the item will be added'),
+  item: AddProductBundleItemInputSchema,
+};
+
+export const AddProductBundleItemZodSchema = z.object(AddProductBundleItemSchema);
+
+export type AddProductBundleItemParams = z.infer<typeof AddProductBundleItemZodSchema>;
+export const addProductBundleItemHandler = async (
+  context: Context,
+  params: AddProductBundleItemParams,
+) => {
+  const { modules, userId } = context;
+  const { productId, item } = params;
+
+  log('handler addProductBundleItemHandler', { userId, params });
+
+  try {
+    const product = await modules.products.findProduct({ productId });
+    if (!product) throw new ProductNotFoundError({ productId });
+
+    if (product.type !== ProductTypes.BundleProduct)
+      throw new ProductWrongTypeError({
+        productId,
+        received: product.type,
+        required: ProductTypes.BundleProduct,
+      });
+
+    if (!(await modules.products.productExists({ productId: item.productId })))
+      throw new ProductNotFoundError({ productId: item.productId });
+
+    await modules.products.bundleItems.addBundleItem(productId, item as any);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ product: await getNormalizedProductDetails(productId, context) }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error adding bundle item: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+};

package/src/mcp/tools/product/addProductMediaUploadHandler.ts

@@ -2,6 +2,7 @@ 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 AddProductMediaUploadSchema = {
   mediaName: z
@@ -24,7 +25,7 @@ export async function addProductMediaUploadHandler(
   const { modules, services, userId } = context;
 
   try {
-    log('handler addProductAssignmentHandler', { userId, params });
+    log('handler addProductMediaUploadHandler', { userId, params });
     const {
       _id: fileId,
       putURL,
@@ -61,7 +62,7 @@ export async function addProductMediaUploadHandler(
         {
           type: 'text' as const,
           text: JSON.stringify({
-            file: linked,
+            file: await normalizeMediaUrl([{ ...linked, mediaId: linked._id }], context),
           }),
         },
       ],

package/src/mcp/tools/product/catalogPriceHandler.ts

@@ -0,0 +1,61 @@
+import { Context } from '../../../context.js';
+import { ProductNotFoundError } from '../../../errors.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
+import { z } from 'zod';
+
+export const CatalogPriceSchema = {
+  productId: z.string().min(1).describe('ID of the product to retrieve catalog price for'),
+  quantity: z
+    .number()
+    .int()
+    .positive()
+    .default(1)
+    .describe('Quantity to calculate catalog price for (default is 1)'),
+  currencyCode: z
+    .string()
+    .optional()
+    .describe('Optional currency code (e.g., "USD") for price calculation'),
+};
+
+export const CatalogPriceZodSchema = z.object(CatalogPriceSchema);
+export type CatalogPriceParams = z.infer<typeof CatalogPriceZodSchema>;
+
+export async function catalogPriceHandler(context: Context, params: CatalogPriceParams) {
+  const { productId, quantity, currencyCode: forcedCurrencyCode } = params;
+  const { modules, countryCode, currencyCode: defaultCurrencyCode, userId } = context;
+
+  try {
+    log('handler catalogPriceHandler', { userId, params });
+    const product = await getNormalizedProductDetails(productId, context);
+    if (!product) throw new ProductNotFoundError({ productId });
+    const currencyCode = forcedCurrencyCode || defaultCurrencyCode;
+    const catalogPrice = await modules.products.prices.price(product, {
+      countryCode,
+      currencyCode,
+      quantity,
+    });
+    const leveledCatalogPrice = await modules.products.prices.catalogPricesLeveled(product, {
+      currencyCode,
+      countryCode,
+    });
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ product, price: catalogPrice, leveledCatalogPrice }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+
+          text: `Error retrieving catalog price: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -71,6 +71,27 @@ import {
   translatedProductVariationTextsHandler,
   TranslatedProductVariationTextsSchema,
 } from './translatedProductVariationTextsHandler.js';
+import {
+  updateProductVariationTextsHandler,
+  UpdateProductVariationTextsSchema,
+} from './updateProductVariationTextsHandler.js';
+import { productSiblingsHandler, ProductSiblingsSchema } from './productSiblingsHandler.js';
+import { productMediaHandler, ProductMediaSchema } from './productMediaHandler.js';
+import { variationProductsHandler, VariationProductsSchema } from './variationProductsHandler.js';
+import { productVariationsHandler, ProductVariationsSchema } from './productVariationsHandler.js';
+import {
+  addProductBundleItemHandler,
+  AddProductBundleItemSchema,
+} from './addProductBundleItemHandler.js';
+import {
+  removeProductBundleItemHandler,
+  RemoveProductBundleItemSchema,
+} from './removeProductBundleItemHandler.js';
+import { productAssignmentsHandler, ProductAssignmentsSchema } from './productAssignmentsHandler.js';
+import { productBundleItemsHandler, ProductBundleItemsSchema } from './productBundleItemsHandler.js';
+import { simulatedPriceRangeHandler, SimulatedPriceRangeSchema } from './simulatedPriceRangeHandler.js';
+import { simulatedPriceHandler, SimulatedPriceSchema } from './simulatedPriceHandler.js';
+import { catalogPriceHandler, CatalogPriceSchema } from './catalogPriceHandler.js';
 
 export const registerProductTools = (server: McpServer, context: Context) => {
   server.tool(
@@ -161,7 +182,7 @@ export const registerProductTools = (server: McpServer, context: Context) => {
   );
   server.tool(
     'product_updatePlan',
-    'Update the plan details for a PLAN_PRODUCT type product',
+    'Update the subscription plan configuration for a product of type PLAN. This includes usage calculation type (LICENSED or METERED), billing interval settings, and optional trial period configuration. This operation is only valid for products with type PLAN_PRODUCT.',
     UpdateProductPlanSchema,
     async (params) => updateProductPlanHandler(context, params),
   );
@@ -182,7 +203,7 @@ export const registerProductTools = (server: McpServer, context: Context) => {
 
   server.tool(
     'product_assignVariation',
-    'Assign a product variant to a configurable product with a unique combination of attribute vectors.',
+    'Assign a product variant to a configurable product with a unique combination of option vectors. assigning with incomplete vector will fail. make sure all variation options are selected before calling this tool.',
     AssignProductVariationSchema,
     async (params) => addProductAssignmentHandler(context, params),
   );
@@ -230,7 +251,7 @@ export const registerProductTools = (server: McpServer, context: Context) => {
   );
 
   server.tool(
-    'product_media_reorder',
+    'product_reorderMedias',
     'Reorder media assets of a product by providing new sort keys.',
     ReorderProductMediaSchema,
     async (params) => reorderProductMediaHandler(context, params),
@@ -269,4 +290,84 @@ export const registerProductTools = (server: McpServer, context: Context) => {
     TranslatedProductVariationTextsSchema,
     async (params) => translatedProductVariationTextsHandler(context, params),
   );
+  server.tool(
+    'productVariation_updateTexts',
+    'Update product variation texts with the specified locales for product variations that match the provided variation ID and production option value.',
+    UpdateProductVariationTextsSchema,
+    async (params) => updateProductVariationTextsHandler(context, params),
+  );
+  server.tool(
+    'product_siblings',
+    'Retrieve sibling products of a given product, optionally filtered by assortment ID, with support for pagination and inclusion of inactive products.',
+    ProductSiblingsSchema,
+    async (params) => productSiblingsHandler(context, params),
+  );
+
+  server.tool(
+    'product_getMedias',
+    'Retrieve media assets associated with a product, optionally filtered by tags and paginated.',
+    ProductMediaSchema,
+    async (params) => productMediaHandler(context, params),
+  );
+  server.tool(
+    'product_variationProducts',
+    'Retrieve all variant products of a configurable product that exactly match the provided combination of variation key-value pairs (e.g., Color: Red, Size: M). You must provide at least one vector. Optionally include inactive variants in the result.',
+    VariationProductsSchema,
+    async (params) => variationProductsHandler(context, params),
+  );
+
+  server.tool(
+    'product_variations',
+    'Retrieve all defined variation attributes (e.g., Color, Size) and their possible values for a configurable product.',
+    ProductVariationsSchema,
+    async (params) => productVariationsHandler(context, params),
+  );
+
+  server.tool(
+    'product_addBundleItem',
+    'Adds a product as a bundled item to another product. Only works if the target product is of type BUNDLE_PRODUCT. You must provide the ID of the bundle and the ID and quantity of the item to include.',
+    AddProductBundleItemSchema,
+    async (params) => addProductBundleItemHandler(context, params),
+  );
+
+  server.tool(
+    'product_removeBundleItem',
+    'Removes a bundled product from a BUNDLE_PRODUCT using its 0-based index in the bundle list. The product must be of type BUNDLE_PRODUCT.',
+    RemoveProductBundleItemSchema,
+    async (params) => removeProductBundleItemHandler(context, params),
+  );
+
+  server.tool(
+    'product_assignments',
+    'Retrieve the full assignment matrix of a configurable product, including all assigned variants by their variation vectors. Optionally include inactive variants.',
+    ProductAssignmentsSchema,
+    async (params) => productAssignmentsHandler(context, params),
+  );
+
+  server.tool(
+    'product_bundleItems',
+    'Retrieve all bundle items from a product of type BUNDLE. Each item includes the configuration and quantity.',
+    ProductBundleItemsSchema,
+    async (params) => productBundleItemsHandler(context, params),
+  );
+
+  server.tool(
+    'product_simulatedPriceRange',
+    'Simulate the price range for a CONFIGURABLE_PRODUCT and its variant combinations based on quantity, variation selections, and pricing rules. Only applicable to configurable products.',
+    SimulatedPriceRangeSchema,
+    async (params) => simulatedPriceRangeHandler(context, params),
+  );
+  server.tool(
+    'product_simulatedPrice',
+    'Simulate the price for a product given a complete configuration vector and quantity. Useful for previewing dynamic pricing rules.',
+    SimulatedPriceSchema,
+    async (params) => simulatedPriceHandler(context, params),
+  );
+
+  server.tool(
+    'product_catalogPrice',
+    'Retrieve the catalog price for any product type, optionally for a specific quantity and currency. when ask for product price without specifying what, always use this tool',
+    CatalogPriceSchema,
+    async (params) => catalogPriceHandler(context, params),
+  );
 };

package/src/mcp/tools/product/productAssignmentsHandler.ts

@@ -0,0 +1,86 @@
+import { Context } from '../../../context.js';
+import { ProductNotFoundError, ProductWrongTypeError } from '../../../errors.js';
+import { ProductTypes } from '@unchainedshop/core-products';
+import { log } from '@unchainedshop/logger';
+import { z } from 'zod';
+import normalizeMediaUrl from '../../utils/normalizeMediaUrl.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+
+export const ProductAssignmentsSchema = {
+  productId: z
+    .string()
+    .min(1)
+    .describe('ID of the CONFIGURABLE_PRODUCT whose assignments should be fetched'),
+  includeInactive: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe('Whether to include inactive assigned products'),
+};
+
+export const ProductAssignmentsZodSchema = z.object(ProductAssignmentsSchema);
+export type ProductAssignmentsParams = z.infer<typeof ProductAssignmentsZodSchema>;
+
+export const productAssignmentsHandler = async (context: Context, params: ProductAssignmentsParams) => {
+  const { modules, userId, loaders, locale } = context;
+  const { productId, includeInactive } = params;
+
+  log('handler productAssignmentsHandler', { userId, params });
+  try {
+    const product = await getNormalizedProductDetails(productId, context);
+    if (!product) throw new ProductNotFoundError({ productId });
+
+    if (product.type !== ProductTypes.ConfigurableProduct) {
+      throw new ProductWrongTypeError({
+        productId,
+        received: product.type,
+        required: ProductTypes.ConfigurableProduct,
+      });
+    }
+
+    const assignments = await modules.products.proxyAssignments(product, { includeInactive });
+    const normalizedAssignments = await Promise.all(
+      assignments.map(async ({ assignment, ...rest }) => {
+        const product = await loaders.productLoader.load({
+          productId: assignment.productId,
+        });
+        const productMedias = await modules.products.media.findProductMedias({
+          productId: assignment.productId,
+        });
+        const media = await normalizeMediaUrl(productMedias, context);
+        const texts = await loaders.productTextLoader.load({
+          productId: assignment.productId,
+          locale,
+        });
+        return {
+          assignment: {
+            ...assignment,
+            product: {
+              ...product,
+              media,
+              texts,
+            },
+          },
+          ...rest,
+        };
+      }),
+    );
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ product, assignments: normalizedAssignments }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error fetching assignments: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+};