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

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

@@ -0,0 +1,373 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Context } from '../../../context.js';
+import { productsListHandler, ProductsListSchema } from './listProducts.js';
+import { productsCountHandler, ProductsCountSchema } from './productsCountHandler.js';
+import { getProductHandler, GetProductSchema } from './getProduct.js';
+import { createProductHandler, CreateProductSchema } from './createProductHandler.js';
+import { removeProductHandler, RemoveProductSchema } from './removeProductHandler.js';
+import { publishProductHandler, PublishProductSchema } from './publishProduct.js';
+import { unpublishProductHandler, UnpublishProductSchema } from './unpublishProductHandler.js';
+import { updateProductHandler, UpdateProductSchema } from './updateProductHandler.js';
+import { updateProductTextsHandler, UpdateProductTextsSchema } from './updateProductTextsHandler.js';
+import {
+  updateProductCommerceHandler,
+  UpdateProductCommerceSchema,
+} from './updateProductCommerceHandler.js';
+import {
+  updateProductWarehousingHandler,
+  UpdateProductWarehousingSchema,
+} from './updateProductWarehousingHandler.js';
+import { updateProductSupplyHandler, UpdateProductSupplySchema } from './updateProductSupplyHandler.js';
+import {
+  updateProductTokenizationHandler,
+  UpdateProductTokenizationSchema,
+} from './updateProductTokenizationHandler.js';
+import { updateProductPlanHandler, UpdateProductPlanSchema } from './updateProductPlanHandler.js';
+import {
+  removeProductVariationHandler,
+  RemoveProductVariationSchema,
+} from './removeProductVariationHandler.js';
+import {
+  createProductVariationHandler,
+  CreateProductVariationSchema,
+} from './createProductVariationHandler.js';
+import {
+  addProductAssignmentHandler,
+  AssignProductVariationSchema,
+} from './addProductAssignmentHandler.js';
+import {
+  createProductVariationOptionHandler,
+  CreateProductVariationOptionSchema,
+} from './createProductVariationOptionHandler.js';
+import {
+  removeProductVariationOptionHandler,
+  RemoveProductVariationOptionSchema,
+} from './removeProductVariationOptionHandler.js';
+import {
+  removeProductAssignmentHandler,
+  RemoveProductAssignmentSchema,
+} from './removeProductAssignmentHandler.js';
+import {
+  addProductMediaUploadHandler,
+  AddProductMediaUploadSchema,
+} from './addProductMediaUploadHandler.js';
+import { removeProductMediaHandler, RemoveProductMediaSchema } from './removeProductMediaHandler.js';
+import {
+  updateProductMediaTextsHandler,
+  UpdateProductMediaTextsSchema,
+} from './updateProductMediaTextsHandler.js';
+import { reorderProductMediaHandler, ReorderProductMediaSchema } from './reorderProductMediaHandler.js';
+import { productReviewsCountHandler, ProductReviewsCountSchema } from './productReviewsCountHandler.js';
+import { productReviewsHandler, ProductReviewsSchema } from './productReviewsHandler.js';
+import {
+  translatedProductTextsHandler,
+  TranslatedProductTextsSchema,
+} from './translatedProductTextsHandler.js';
+import {
+  translatedProductMediaTextsHandler,
+  TranslatedProductMediaTextsSchema,
+} from './translatedProductMediaTextsHandler.js';
+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(
+    'product_list',
+    'List products filtered by tags, slugs, or query string; supports pagination and sorting.',
+    ProductsListSchema,
+    async (params) => productsListHandler(context, params),
+  );
+
+  server.tool(
+    'product_count',
+    'Count products filtered by tags, slugs, draft status, or query string.',
+    ProductsCountSchema,
+    async (params) => productsCountHandler(context, params),
+  );
+  server.tool(
+    'product_get',
+    'Retrieve product details by productId, slug, or SKU.',
+    GetProductSchema,
+    async (params) => getProductHandler(context, params),
+  );
+
+  server.tool(
+    'product_create',
+    'Create a new product with localized text information. it will be in DRAFT/unpublish status',
+    CreateProductSchema,
+    async (params) => createProductHandler(context, params),
+  );
+  server.tool(
+    'product_remove',
+    'Remove a product by its ID. Changing its status to DELETED and removing it from sale',
+    RemoveProductSchema,
+    async (params) => removeProductHandler(context, params),
+  );
+
+  server.tool(
+    'product_publish',
+    'Publish a product by its id changing it to active and available for sale',
+    PublishProductSchema,
+    async (params) => publishProductHandler(context, params),
+  );
+
+  server.tool(
+    'product_unpublish',
+    'Deactivates or Unpublishes product by its id changing it to DRAFT and not available for sale',
+    UnpublishProductSchema,
+    async (params) => unpublishProductHandler(context, params),
+  );
+  server.tool(
+    'product_update',
+    'Update specified fields (such as tags, sequence, and metadata) of an existing product identified by its productId.',
+    UpdateProductSchema,
+    async (params) => updateProductHandler(context, params),
+  );
+
+  server.tool(
+    'product_updateTexts',
+    'Update localized texts (title, subtitle, description, slug, vendor, brand, labels) of a product',
+    UpdateProductTextsSchema,
+    async (params) => updateProductTextsHandler(context, params),
+  );
+
+  server.tool(
+    'product_updateCommerce',
+    'Update commerce information (pricing) for a product (all types except CONFIGURABLE_PRODUCT)',
+    UpdateProductCommerceSchema,
+    async (params) => updateProductCommerceHandler(context, params),
+  );
+
+  server.tool(
+    'product_updateWarehousing',
+    'Update warehousing details (SKU, base unit) for a SIMPLE_PRODUCT type product',
+    UpdateProductWarehousingSchema,
+    async (params) => updateProductWarehousingHandler(context, params),
+  );
+
+  server.tool(
+    'product_updateSupply',
+    'Update the supply (delivery) details for a SIMPLE_PRODUCT type product',
+    UpdateProductSupplySchema,
+    async (params) => updateProductSupplyHandler(context, params),
+  );
+  server.tool(
+    'product_updateTokenization',
+    'Update tokenization details for a TOKENIZED_PRODUCT type product',
+    UpdateProductTokenizationSchema,
+    async (params) => updateProductTokenizationHandler(context, params),
+  );
+  server.tool(
+    'product_updatePlan',
+    '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),
+  );
+
+  server.tool(
+    'product_createVariation',
+    'Create a variation for a CONFIGURABLE_PRODUCT product including localized texts.',
+    CreateProductVariationSchema,
+    async (params) => createProductVariationHandler(context, params),
+  );
+
+  server.tool(
+    'productVariation_remove',
+    'Remove a product variation by its ID.',
+    RemoveProductVariationSchema,
+    async (params) => removeProductVariationHandler(context, params),
+  );
+
+  server.tool(
+    'product_assignVariation',
+    '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),
+  );
+
+  server.tool(
+    'product_createVariationOption',
+    'Create a new option for a product variation with localized titles and subtitles.',
+    CreateProductVariationOptionSchema,
+    async (params) => createProductVariationOptionHandler(context, params),
+  );
+
+  server.tool(
+    'productVariationOption_remove',
+    'Remove an option from a product variation by its value.',
+    RemoveProductVariationOptionSchema,
+    async (params) => removeProductVariationOptionHandler(context, params),
+  );
+
+  server.tool(
+    'product_removeAssignment',
+    'Remove a product variant assignment from a configurable product using attribute vectors.',
+    RemoveProductAssignmentSchema,
+    async (params) => removeProductAssignmentHandler(context, params),
+  );
+
+  server.tool(
+    'product_addMedia',
+    'Add a media asset to a product from a publicly accessible URL',
+    AddProductMediaUploadSchema,
+    async (params) => addProductMediaUploadHandler(context, params),
+  );
+
+  server.tool(
+    'productMedia_remove',
+    'Remove a product media asset by its ID.',
+    RemoveProductMediaSchema,
+    async (params) => removeProductMediaHandler(context, params),
+  );
+
+  server.tool(
+    'productMedia_updateTexts',
+    'Update localized texts (title, subtitle) of a product media asset.',
+    UpdateProductMediaTextsSchema,
+    async (params) => updateProductMediaTextsHandler(context, params),
+  );
+
+  server.tool(
+    'product_reorderMedias',
+    'Reorder media assets of a product by providing new sort keys.',
+    ReorderProductMediaSchema,
+    async (params) => reorderProductMediaHandler(context, params),
+  );
+
+  server.tool(
+    'productReviews_count',
+    'Count product reviews optionally filtered by query string.',
+    ProductReviewsCountSchema,
+    async (params) => productReviewsCountHandler(context, params),
+  );
+
+  server.tool(
+    'productReviews_list',
+    'Retrieve a paginated list of product reviews with optional filtering and sorting.',
+    ProductReviewsSchema,
+    async (params) => productReviewsHandler(context, params),
+  );
+  server.tool(
+    'product_getTexts',
+    'Retrieve translated texts associated with a specific product_',
+    TranslatedProductTextsSchema,
+    async (params) => translatedProductTextsHandler(context, params),
+  );
+
+  server.tool(
+    'productMedia_getTexts',
+    'Retrieve translated texts associated with a specific product media asset.',
+    TranslatedProductMediaTextsSchema,
+    async (params) => translatedProductMediaTextsHandler(context, params),
+  );
+
+  server.tool(
+    'productVariation_getTexts',
+    'Retrieve translated texts for a product variation or optionally a specific variation option.',
+    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/listProducts.ts

@@ -1,131 +1,36 @@
 import { z } from 'zod';
-import { SortDirection } from '@unchainedshop/utils';
 import { Context } from '../../../context.js';
-import { ProductText } from '@unchainedshop/core-products';
-import normalizeMediaUrl from '../../utils/normalizeMediaUrl.js';
-
-/**
- * Zod schema for the list_products tool (as raw object for MCP)
- */
-export const ListProductsSchema = {
-  // Search & Filter
-  queryString: z.string().optional().describe('Text search across product fields'),
-  tags: z.array(z.string()).optional().describe('Filter by product tags'),
-  productIds: z.array(z.string()).optional().describe('Filter by specific product IDs'),
-  filterQuery: z
-    .array(
-      z.object({
-        key: z.string().describe('Filter key'),
-        value: z.string().optional().describe('Filter value'),
-      }),
-    )
-    .optional()
-    .describe('Key-value filter pairs'),
-  assortmentId: z.string().optional().describe('Filter by assortment'),
-  includeInactive: z.boolean().default(false).describe('Include inactive products'),
-
-  // Pagination
-  limit: z.number().min(1).max(100).default(20).describe('Results per page'),
-  offset: z.number().min(0).default(0).describe('Skip results for pagination'),
-
-  // Sorting
-  sort: z
-    .array(
-      z.object({
-        key: z.string().describe('Sort field'),
-        value: z.enum(['ASC', 'DESC']).describe('Sort direction'),
-      }),
-    )
-    .optional()
-    .describe('Sort options'),
+import { log } from '@unchainedshop/logger';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+
+const SortOptionInputSchema = z.object({
+  key: z.string().min(1).describe('Field to sort by'),
+  value: z.enum(['ASC', 'DESC']).describe('Sort direction'),
+});
+
+export const ProductsListSchema = {
+  queryString: z.string().optional().describe('Free-text filter for products'),
+  tags: z.array(z.string().min(1).toLowerCase()).optional().describe('Filter by lowercase tags'),
+  slugs: z.array(z.string().min(1)).optional().describe('Filter by product slugs'),
+  limit: z.number().int().min(1).max(100).default(10).describe('Maximum number of products to return'),
+  offset: z.number().int().min(0).default(0).describe('Number of products to skip'),
+  includeDrafts: z.boolean().default(false).describe('Whether to include draft (unpublished) products'),
+  sort: z.array(SortOptionInputSchema).optional().describe('Sorting options'),
 };
 
-/**
- * Zod object schema for type inference
- */
-export const ListProductsZodSchema = z.object(ListProductsSchema);
+export const ProductsListZodSchema = z.object(ProductsListSchema);
 
-/**
- * Interface for the list_products tool parameters
- */
-export type ListProductsParams = z.infer<typeof ListProductsZodSchema>;
+export type ProductsListParams = z.infer<typeof ProductsListZodSchema>;
 
-/**
- * Implementation of the list_products tool
- */
-export async function listProductsHandler(context: Context, params: ListProductsParams) {
-  const {
-    queryString,
-    tags,
-    productIds,
-    filterQuery,
-    assortmentId,
-    includeInactive = false,
-    limit = 20,
-    offset = 0,
-    sort,
-  } = params;
+export async function productsListHandler(context: Context, params: ProductsListParams) {
+  const { modules, userId } = context;
 
   try {
-    let filteredProductIds = productIds;
-
-    // If assortmentId is provided, get product IDs from assortment
-    if (assortmentId) {
-      const assortmentProductIds = await context.modules.assortments.products.findProductIds({
-        assortmentId,
-      });
-
-      if (filteredProductIds) {
-        // Intersection of both sets
-        filteredProductIds = filteredProductIds.filter((id) => assortmentProductIds.includes(id));
-      } else {
-        filteredProductIds = assortmentProductIds;
-      }
-    }
+    log('handler productsListHandler', { userId, params });
 
-    let searchResult: any = {};
-    if (queryString)
-      searchResult = await context.services.filters.searchProducts(
-        {
-          queryString,
-          productIds: filteredProductIds,
-          includeInactive,
-          filterQuery: filterQuery?.filter((f) => f.key) as { key: string; value?: string }[],
-        },
-        {
-          locale: context.locale,
-        },
-      );
-    const products = await context.modules.products.findProducts({
-      productIds: searchResult?.aggregatedFilteredProductIds,
-      tags,
-      limit,
-      offset,
-      includeDrafts: includeInactive,
-      sort: sort?.filter((s) => s.key) as { key: string; value: SortDirection }[],
-    });
-
-    const productTexts = await context.loaders.productTextLoader.loadMany(
-      products.map(({ _id }) => ({
-        productId: _id,
-        locale: context.locale,
-      })),
-    );
-
-    // iterate all products and add texts
+    const products = await modules.products.findProducts(params as any);
     const normalizedProducts = await Promise.all(
-      products.map(async (product) => {
-        const texts = productTexts.filter((text) => (text as ProductText)?.productId === product._id);
-        const productMedias = await context.modules.products.media.findProductMedias({
-          productId: product._id,
-        });
-        const media = await normalizeMediaUrl(productMedias, context);
-        return {
-          ...product,
-          texts,
-          media,
-        };
-      }),
+      products.map(async ({ _id }) => getNormalizedProductDetails(_id, context)),
     );
 
     return {
@@ -134,15 +39,18 @@ export async function listProductsHandler(context: Context, params: ListProducts
           type: 'text' as const,
           text: JSON.stringify({
             products: normalizedProducts,
-            total: searchResult?.aggregatedTotalProductIds?.length,
-            filtered: searchResult?.aggregatedFilteredProductIds?.length || products?.length,
           }),
         },
       ],
     };
   } catch (error) {
     return {
-      content: [{ type: 'text' as const, text: `Error listing products: ${(error as Error).message}` }],
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error fetching products: ${(error as Error).message}`,
+        },
+      ],
     };
   }
 }

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}`,
+        },
+      ],
+    };
+  }
+};

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

@@ -0,0 +1,50 @@
+import { Context } from '../../../context.js';
+import { ProductNotFoundError, ProductWrongTypeError } from '../../../errors.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { ProductTypes } from '@unchainedshop/core-products';
+import { log } from '@unchainedshop/logger';
+import { z } from 'zod';
+
+export const ProductBundleItemsSchema = {
+  productId: z.string().min(1).describe('ID of the product of type BUNDLE to retrieve its bundle items'),
+};
+
+export const ProductBundleItemsZodSchema = z.object(ProductBundleItemsSchema);
+export type ProductBundleItemsParams = z.infer<typeof ProductBundleItemsZodSchema>;
+
+export const productBundleItemsHandler = async (context: Context, params: ProductBundleItemsParams) => {
+  const { modules, userId } = context;
+  const { productId } = params;
+
+  log('handler productBundleItemsHandler', { 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,
+      });
+    }
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ product: await getNormalizedProductDetails(productId, context) }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error fetching bundle items: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+};