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

package/src/mcp/tools/{publishProduct.ts → product/publishProduct.ts}

@@ -1,7 +1,8 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
-import { ProductNotFoundError, ProductWrongStatusError } from '../../errors.js';
-import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+import { Context } from '../../../context.js';
+import { ProductNotFoundError, ProductWrongStatusError } from '../../../errors.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 export const PublishProductSchema = {
   productId: z.string().min(1).describe('ID of the product to publish'),
@@ -13,8 +14,10 @@ export type PublishProductParams = z.infer<typeof PublishProductZodSchema>;
 
 export async function publishProductHandler(context: Context, params: PublishProductParams) {
   const { productId } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
+
   try {
+    log('handler publishProductHandler', { userId, params });
     const product = await modules.products.findProduct({ productId });
     if (!product) throw new ProductNotFoundError({ productId });
 

package/src/mcp/tools/{removeProductAssignmentHandler.ts → product/removeProductAssignmentHandler.ts}

@@ -1,8 +1,9 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
-import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
-import { ProductWrongTypeError } from '../../errors.js';
+import { Context } from '../../../context.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { ProductWrongTypeError } from '../../../errors.js';
 import { ProductTypes } from '@unchainedshop/core-products';
+import { log } from '@unchainedshop/logger';
 
 const ProductAssignmentVectorSchema = z.object({
   key: z.string().min(1).describe('Attribute key (e.g., "Color", "Size")'),
@@ -24,9 +25,10 @@ export async function removeProductAssignmentHandler(
   params: RemoveProductAssignmentParams,
 ) {
   const { proxyId, vectors } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler removeProductAssignmentHandler', { userId, params });
     const product = await modules.products.findProduct({ productId: proxyId });
 
     if (product.type !== ProductTypes.ConfigurableProduct)

package/src/mcp/tools/{removeProductHandler.ts → product/removeProductHandler.ts}

@@ -1,6 +1,7 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
-import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+import { Context } from '../../../context.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 export const RemoveProductSchema = {
   productId: z.string().min(1).describe('ID of the product to remove'),
@@ -12,9 +13,10 @@ export type RemoveProductParams = z.infer<typeof RemoveProductZodSchema>;
 
 export async function removeProductHandler(context: Context, params: RemoveProductParams) {
   const { productId } = params;
-  const { services } = context;
+  const { services, userId } = context;
 
   try {
+    log('handler removeProductHandler', { userId, params });
     await services.products.removeProduct({ productId });
 
     return {

package/src/mcp/tools/{removeProductMediaHandler.ts → product/removeProductMediaHandler.ts}

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
+import { Context } from '../../../context.js';
 import { log } from '@unchainedshop/logger';
-import { ProductMediaNotFoundError } from '../../errors.js';
+import { ProductMediaNotFoundError } from '../../../errors.js';
 
 export const RemoveProductMediaSchema = {
   productMediaId: z.string().min(1).describe('ID of the product media to be removed'),
@@ -16,7 +16,7 @@ export async function removeProductMediaHandler(context: Context, params: Remove
   const { modules, userId } = context;
 
   try {
-    log('removeProductMediaHandler', { userId, productMediaId });
+    log('handler removeProductMediaHandler', { userId, params });
 
     const productMedia = await modules.products.media.findProductMedia({
       productMediaId,

package/src/mcp/tools/{removeProductVariationHandler.ts → product/removeProductVariationHandler.ts}

@@ -1,7 +1,8 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
-import { ProductVariationNotFoundError } from '../../errors.js';
-import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+import { Context } from '../../../context.js';
+import { ProductVariationNotFoundError } from '../../../errors.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 export const RemoveProductVariationSchema = {
   productVariationId: z
@@ -18,9 +19,10 @@ export async function removeProductVariationHandler(
   params: RemoveProductVariationParams,
 ) {
   const { productVariationId } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler removeProductVariationHandler', { userId, params });
     const productVariation = await modules.products.variations.findProductVariation({
       productVariationId,
     });

package/src/mcp/tools/{removeProductVariationOptionHandler.ts → product/removeProductVariationOptionHandler.ts}

@@ -1,7 +1,8 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
-import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
-import { ProductVariationNotFoundError } from '../../errors.js';
+import { Context } from '../../../context.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { ProductVariationNotFoundError } from '../../../errors.js';
+import { log } from '@unchainedshop/logger';
 
 export const RemoveProductVariationOptionSchema = {
   productVariationId: z
@@ -22,9 +23,10 @@ export async function removeProductVariationOptionHandler(
   params: RemoveProductVariationOptionParams,
 ) {
   const { productVariationId, productVariationOptionValue } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler removeProductVariationOptionHandler', { userId, params });
     const productVariation = await modules.products.variations.findProductVariation({
       productVariationId,
     });

package/src/mcp/tools/{reorderProductMediaHandler.ts → product/reorderProductMediaHandler.ts}

@@ -1,5 +1,5 @@
 import { log } from '@unchainedshop/logger';
-import { Context } from '../../context.js';
+import { Context } from '../../../context.js';
 import { z } from 'zod';
 
 export const ReorderProductMediaSchema = {
@@ -23,7 +23,7 @@ export async function reorderProductMediaHandler(context: Context, params: Reord
   const { modules, userId } = context;
 
   try {
-    log('mutation reorderProductMedia', { userId });
+    log('handler reorderProductMediaHandler', { userId, params });
 
     const reorderedMedia = await modules.products.media.updateManualOrder({ sortKeys: sortKeys as any });
 

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

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const TranslatedProductMediaTextsSchema = {
+  productMediaId: z.string().min(1).describe('ID of the product media to fetch translated texts for'),
+};
+
+export const TranslatedProductMediaTextsZodSchema = z.object(TranslatedProductMediaTextsSchema);
+
+export type TranslatedProductMediaTextsParams = z.infer<typeof TranslatedProductMediaTextsZodSchema>;
+
+export async function translatedProductMediaTextsHandler(
+  context: Context,
+  params: TranslatedProductMediaTextsParams,
+) {
+  const { productMediaId } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`handler translatedProductMediaTexts`, { userId, params });
+
+    const texts = await modules.products.media.texts.findMediaTexts({ productMediaId });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ texts }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error getting translated product media texts: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const TranslatedProductTextsSchema = {
+  productId: z.string().min(1).describe('ID of the product to fetch translated texts for'),
+};
+
+export const TranslatedProductTextsZodSchema = z.object(TranslatedProductTextsSchema);
+
+export type TranslatedProductTextsParams = z.infer<typeof TranslatedProductTextsZodSchema>;
+
+export async function translatedProductTextsHandler(
+  context: Context,
+  params: TranslatedProductTextsParams,
+) {
+  const { productId } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`handler translatedProductTexts`, { userId, params });
+
+    const texts = await modules.products.texts.findTexts({ productId });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ texts }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error getting translated product texts: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

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

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export const TranslatedProductVariationTextsSchema = {
+  productVariationId: z.string().min(1).describe('ID of the product variation'),
+  productVariationOptionValue: z
+    .string()
+    .optional()
+    .describe('Optional specific variation option value'),
+};
+
+export const TranslatedProductVariationTextsZodSchema = z.object(TranslatedProductVariationTextsSchema);
+
+export type TranslatedProductVariationTextsParams = z.infer<
+  typeof TranslatedProductVariationTextsZodSchema
+>;
+
+export async function translatedProductVariationTextsHandler(
+  context: Context,
+  params: TranslatedProductVariationTextsParams,
+) {
+  const { productVariationId, productVariationOptionValue } = params;
+  const { modules, userId } = context;
+
+  try {
+    log(`handler translatedProductVariationTexts`, {
+      userId,
+      params,
+    });
+
+    const texts = await modules.products.variations.texts.findVariationTexts({
+      productVariationId,
+      productVariationOptionValue,
+    });
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ texts }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error getting translated product variation texts: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/{unPublishProduct.ts → product/unpublishProductHandler.ts}

@@ -1,7 +1,8 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
-import { ProductNotFoundError, ProductWrongStatusError } from '../../errors.js';
-import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+import { Context } from '../../../context.js';
+import { ProductNotFoundError, ProductWrongStatusError } from '../../../errors.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 export const UnpublishProductSchema = {
   productId: z.string().min(1).describe('ID of the product to unpublish'),
@@ -13,8 +14,8 @@ export type UnpublishProductParams = z.infer<typeof UnpublishProductZodSchema>;
 
 export async function unpublishProductHandler(context: Context, params: UnpublishProductParams) {
   const { productId } = params;
-  const { modules } = context;
-
+  const { modules, userId } = context;
+  log('handler unpublishProductHandler', { userId, params });
   try {
     const product = await modules.products.findProduct({ productId });
     if (!product) throw new ProductNotFoundError({ productId });

package/src/mcp/tools/{updateProductCommerceHandler.ts → product/updateProductCommerceHandler.ts}

@@ -1,6 +1,7 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
-import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+import { Context } from '../../../context.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 export const UpdateProductCommerceSchema = {
   productId: z
@@ -51,9 +52,10 @@ export async function updateProductCommerceHandler(
   params: UpdateProductCommerceParams,
 ) {
   const { productId, commerce } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler updateProductCommerceHandler', { userId, params });
     await modules.products.update(productId, { commerce });
 
     return {

package/src/mcp/tools/{updateProduct.ts → product/updateProductHandler.ts}

@@ -1,7 +1,8 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
-import { ProductNotFoundError } from '../../errors.js';
-import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+import { Context } from '../../../context.js';
+import { ProductNotFoundError } from '../../../errors.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 export const UpdateProductSchema = {
   productId: z.string().min(1).describe('ID of the product to update'),
@@ -20,9 +21,10 @@ export type UpdateProductParams = z.infer<typeof UpdateProductZodSchema>;
 
 export async function updateProductHandler(context: Context, params: UpdateProductParams) {
   const { productId, product } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler updateProductHandler', { userId, params });
     if (!(await modules.products.productExists({ productId })))
       throw new ProductNotFoundError({ productId });
 

package/src/mcp/tools/{updateProductMediaTextsHandler.ts → product/updateProductMediaTextsHandler.ts}

@@ -1,13 +1,19 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
-import { ProductMediaNotFoundError } from '../../errors.js';
+import { Context } from '../../../context.js';
+import { ProductMediaNotFoundError } from '../../../errors.js';
+import { log } from '@unchainedshop/logger';
 
 export const UpdateProductMediaTextsSchema = {
   productMediaId: z.string().min(1).describe('ID of the media asset to update'),
   texts: z
     .array(
       z.object({
-        locale: z.string().min(2).describe('Locale of the text, e.g. "en", "fr", etc.'),
+        locale: z
+          .string()
+          .min(2)
+          .describe(
+            'locale iso code like "en-US", "de-CH" use default defaultLanguageIsoCode in shop info if not explicitly provided. if language is explicitly provided check if it exists',
+          ),
         title: z.string().optional().describe('Title in the given locale'),
         subtitle: z.string().optional().describe('Subtitle in the given locale'),
       }),
@@ -25,9 +31,10 @@ export async function updateProductMediaTextsHandler(
   params: UpdateProductMediaTextsParams,
 ) {
   const { productMediaId, texts } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler updateProductMediaTextsHandler', { userId, params });
     const productMedia = await modules.products.media.findProductMedia({
       productMediaId,
     });

package/src/mcp/tools/{updateProductPlanHandler.ts → product/updateProductPlanHandler.ts}

@@ -1,17 +1,18 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
-import { ProductNotFoundError, ProductWrongStatusError } from '../../errors.js';
+import { Context } from '../../../context.js';
+import { ProductNotFoundError, ProductWrongStatusError } from '../../../errors.js';
 import { ProductTypes } from '@unchainedshop/core-products';
-import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 export const UpdateProductPlanSchema = {
   productId: z.string().min(1).describe('ID of the product of type PLAN_PRODUCT to update only'),
   plan: z.object({
-    usageCalculationType: z.string(),
-    billingInterval: z.string(),
-    billingIntervalCount: z.number().int().positive().optional(),
-    trialInterval: z.string().optional(),
-    trialIntervalCount: z.number().int().positive().optional(),
+    usageCalculationType: z.string().describe('Type of usage calculation'),
+    billingInterval: z.string().describe('Billing interval, e.g., "month", "year"'),
+    billingIntervalCount: z.number().int().positive().optional().describe('Count of billing intervals'),
+    trialInterval: z.string().optional().describe('Trial period interval'),
+    trialIntervalCount: z.number().int().positive().optional().describe('Count of trial intervals'),
   }),
 };
 
@@ -21,9 +22,10 @@ export type UpdateProductPlanParams = z.infer<typeof UpdateProductPlanZodSchema>
 
 export async function updateProductPlanHandler(context: Context, params: UpdateProductPlanParams) {
   const { productId, plan } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler updateProductPlanHandler', { userId, params });
     const product = await modules.products.findProduct({ productId });
     if (!product) throw new ProductNotFoundError({ productId });
 

package/src/mcp/tools/{updateProductSupplyHandler.ts → product/updateProductSupplyHandler.ts}

@@ -1,8 +1,9 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
-import { ProductWrongTypeError } from '../../errors.js';
+import { Context } from '../../../context.js';
+import { ProductWrongTypeError } from '../../../errors.js';
 import { ProductTypes } from '@unchainedshop/core-products';
-import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 export const UpdateProductSupplySchema = {
   productId: z
@@ -11,10 +12,25 @@ export const UpdateProductSupplySchema = {
     .describe('Product ID of a SIMPLE_PRODUCT only to update supply details for'),
   supply: z
     .object({
-      weightInGram: z.number().int().positive().optional(),
-      heightInMillimeters: z.number().int().positive().optional(),
-      lengthInMillimeters: z.number().int().positive().optional(),
-      widthInMillimeters: z.number().int().positive().optional(),
+      weightInGram: z.number().int().positive().optional().describe('Weight of the product in grams'),
+      heightInMillimeters: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('Height of the product in millimeters'),
+      lengthInMillimeters: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('Length of the product in millimeters'),
+      widthInMillimeters: z
+        .number()
+        .int()
+        .positive()
+        .optional()
+        .describe('Width of the product in millimeters'),
     })
     .describe('Supply (delivery) attributes of the product'),
 };
@@ -25,9 +41,10 @@ export type UpdateProductSupplyParams = z.infer<typeof UpdateProductSupplyZodSch
 
 export async function updateProductSupplyHandler(context: Context, params: UpdateProductSupplyParams) {
   const { productId, supply } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler updateProductSupplyHandler', { userId, params });
     const product = await modules.products.findProduct({ productId });
     if (product?.type !== ProductTypes.SimpleProduct)
       throw new ProductWrongTypeError({

package/src/mcp/tools/{updateProductTextsHandler.ts → product/updateProductTextsHandler.ts}

@@ -1,6 +1,7 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
-import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+import { Context } from '../../../context.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 export const UpdateProductTextsSchema = {
   productId: z.string().min(1).describe('ID of the product to update texts for'),
@@ -11,7 +12,7 @@ export const UpdateProductTextsSchema = {
           .string()
           .min(2)
           .describe(
-            'Locale code like "en", "de" always use locales registered in the system languages, if explicitly provided check if it exists',
+            'locale iso code like "en-US", "de-CH" use default defaultLanguageIsoCode in shop info if not explicitly provided. if language is explicitly provided check if it exists',
           ),
         slug: z.string().optional().describe('URL slug'),
         title: z.string().optional().describe('Product title'),
@@ -32,9 +33,10 @@ export type UpdateProductTextsParams = z.infer<typeof UpdateProductTextsZodSchem
 
 export async function updateProductTextsHandler(context: Context, params: UpdateProductTextsParams) {
   const { productId, texts } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler updateProductTextsHandler', { userId, params });
     await modules.products.texts.updateTexts(productId, texts as any[]);
     return {
       content: [

package/src/mcp/tools/{updateProductTokenizationHandler.ts → product/updateProductTokenizationHandler.ts}

@@ -1,18 +1,21 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
+import { Context } from '../../../context.js';
 import { ProductTypes } from '@unchainedshop/core-products';
-import { ProductNotFoundError, ProductWrongStatusError } from '../../errors.js';
-import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+import { ProductNotFoundError, ProductWrongStatusError } from '../../../errors.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 export const UpdateProductTokenizationSchema = {
   productId: z.string().min(1).describe('ID of the product of type TOKENIZED_PRODUCT to tokenize only'),
-  tokenization: z.object({
-    contractAddress: z.string().min(1),
-    contractStandard: z.string(),
-    tokenId: z.string().min(1),
-    supply: z.number().int().positive(),
-    ercMetadataProperties: z.record(z.any()).optional(),
-  }),
+  tokenization: z
+    .object({
+      contractAddress: z.string().min(1).describe('Blockchain contract address'),
+      contractStandard: z.string().describe('Standard of the smart contract (e.g., ERC-721)'),
+      tokenId: z.string().min(1).describe('Unique token identifier'),
+      supply: z.number().int().positive().describe('Total supply of the token'),
+      ercMetadataProperties: z.record(z.any()).optional().describe('Optional ERC metadata properties'),
+    })
+    .describe('Tokenization details'),
 };
 
 export const UpdateProductTokenizationZodSchema = z.object(UpdateProductTokenizationSchema);
@@ -23,9 +26,10 @@ export async function updateProductTokenizationHandler(
   params: UpdateProductTokenizationParams,
 ) {
   const { productId, tokenization } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler updateProductTokenizationHandler', { userId, params });
     const product = await modules.products.findProduct({ productId });
     if (!product) throw new ProductNotFoundError({ productId });
 

package/src/mcp/tools/{updateProductWarehousingHandler.ts → product/updateProductWarehousingHandler.ts}

@@ -1,15 +1,18 @@
 import { z } from 'zod';
-import { Context } from '../../context.js';
-import { ProductWrongTypeError } from '../../errors.js';
+import { Context } from '../../../context.js';
+import { ProductWrongTypeError } from '../../../errors.js';
 import { ProductTypes } from '@unchainedshop/core-products';
-import { getNormalizedProductDetails } from '../utils/getNormalizedProductDetails.js';
+import { getNormalizedProductDetails } from '../../utils/getNormalizedProductDetails.js';
+import { log } from '@unchainedshop/logger';
 
 export const UpdateProductWarehousingSchema = {
-  productId: z.string().min(1).describe('ID of the SIMPLE_PRODUCT product type to update to be updated'),
-  warehousing: z.object({
-    sku: z.string().min(1).optional().describe('Stock keeping unit'),
-    baseUnit: z.string().min(1).optional().describe('Base unit of the product (e.g., "piece", "kg")'),
-  }),
+  productId: z.string().min(1).describe('ID of the SIMPLE_PRODUCT product type to update'),
+  warehousing: z
+    .object({
+      sku: z.string().min(1).optional().describe('Stock keeping unit'),
+      baseUnit: z.string().min(1).optional().describe('Base unit of the product (e.g., "piece", "kg")'),
+    })
+    .describe('Warehousing details to update'),
 };
 
 export const UpdateProductWarehousingZodSchema = z.object(UpdateProductWarehousingSchema);
@@ -21,9 +24,10 @@ export async function updateProductWarehousingHandler(
   params: UpdateProductWarehousingParams,
 ) {
   const { productId, warehousing } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log('handler updateProductWarehousingHandler', { userId, params });
     const product = await modules.products.findProduct({ productId });
     if (product?.type !== ProductTypes.SimpleProduct)
       throw new ProductWrongTypeError({

package/src/mcp/tools/shopInfoHandler.ts

@@ -0,0 +1,33 @@
+import { Context } from '../../context.js';
+import { log } from '@unchainedshop/logger';
+
+export async function shopInfoHandler(context: Context) {
+  const { version, userId, loaders, locale, countryCode } = context;
+
+  try {
+    log('query shopInfo', { userId });
+
+    const language = await loaders.languageLoader.load({ isoCode: locale.language });
+
+    const country = await loaders.countryLoader.load({ isoCode: countryCode });
+    const defaultLanguageIsoCode = language.isoCode + '-' + country.isoCode;
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ version, defaultLanguageIsoCode, country, language }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error getting shop info: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}