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

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

@@ -19,7 +19,7 @@ export async function removeAssortmentProductHandler(
   const { modules, userId } = context;
 
   try {
-    log(`handler removeAssortmentProduct: ${assortmentProductId}`, { userId });
+    log(`handler removeAssortmentProductHandler`, { userId, params });
 
     const assortmentProduct = await modules.assortments.products.findAssortmentProduct({
       assortmentProductId,

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

@@ -3,8 +3,8 @@ import { Context } from '../../../context.js';
 import { log } from '@unchainedshop/logger';
 
 export const ReorderAssortmentFilterInputSchema = z.object({
-  assortmentFilterId: z.string().min(1),
-  sortKey: z.number().int(),
+  assortmentFilterId: z.string().min(1).describe('ID of the assortment filter to reorder'),
+  sortKey: z.number().int().describe('New sorting key for the filter'),
 });
 
 export const ReorderAssortmentFiltersSchema = {
@@ -26,7 +26,7 @@ export async function reorderAssortmentFiltersHandler(
   const { modules, userId } = context;
 
   try {
-    log('handler reorderAssortmentFilters', { userId, sortKeys });
+    log('handler reorderAssortmentFiltersHandler', { userId, params });
 
     await modules.assortments.filters.updateManualOrder({
       sortKeys,

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

@@ -3,15 +3,15 @@ import { Context } from '../../../context.js';
 import { log } from '@unchainedshop/logger';
 
 export const ReorderAssortmentLinkInputSchema = z.object({
-  assortmentLinkId: z.string().min(1),
-  sortKey: z.number(),
+  assortmentLinkId: z.string().min(1).describe('ID of the assortment link to reorder'),
+  sortKey: z.number().describe('New sorting key for the link'),
 });
 
 export const ReorderAssortmentLinksSchema = {
   sortKeys: z
     .array(ReorderAssortmentLinkInputSchema)
     .min(1)
-    .describe('New sort order for assortment links'),
+    .describe('Array of assortmentLinkId with their new sort keys'),
 };
 
 export const ReorderAssortmentLinksZodSchema = z.object(ReorderAssortmentLinksSchema);
@@ -26,7 +26,7 @@ export async function reorderAssortmentLinksHandler(
   const { modules, userId } = context;
 
   try {
-    log('handler reorderAssortmentLinks', { userId, sortKeys });
+    log('handler reorderAssortmentLinksHandler', { userId, params });
 
     await modules.assortments.links.updateManualOrder({
       sortKeys: sortKeys,

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

@@ -3,15 +3,17 @@ import { Context } from '../../../context.js';
 import { log } from '@unchainedshop/logger';
 
 export const ReorderAssortmentMediaInputSchema = z.object({
-  assortmentMediaId: z.string().min(1),
-  sortKey: z.number(),
+  assortmentMediaId: z.string().min(1).describe('ID of the assortment media to reorder'),
+  sortKey: z.number().describe('New sorting key for the media (lower means higher priority)'),
 });
 
 export const ReorderAssortmentMediaSchema = {
   sortKeys: z
     .array(ReorderAssortmentMediaInputSchema)
     .min(1)
-    .describe('New sort order for assortment media (first is primary)'),
+    .describe(
+      'Array of assortmentMediaId with their new sort keys; the first item will be the primary media',
+    ),
 };
 
 export const ReorderAssortmentMediaZodSchema = z.object(ReorderAssortmentMediaSchema);
@@ -26,9 +28,9 @@ export async function reorderAssortmentMediaHandler(
   const { modules, userId } = context;
 
   try {
-    log('handler reorderAssortmentMedia', { userId, sortKeys });
+    log('handler reorderAssortmentMediaHandler', { userId, params });
 
-    await modules.assortments.media.updateManualOrder({
+    const media = await modules.assortments.media.updateManualOrder({
       sortKeys,
     } as any);
 
@@ -36,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/reorderAssortmentProductsHandler.ts

@@ -3,15 +3,15 @@ import { Context } from '../../../context.js';
 import { log } from '@unchainedshop/logger';
 
 export const ReorderAssortmentProductInputSchema = z.object({
-  assortmentProductId: z.string().min(1),
-  sortKey: z.number(),
+  assortmentProductId: z.string().min(1).describe('ID of the assortment product to reorder'),
+  sortKey: z.number().describe('New sorting key for the product'),
 });
 
 export const ReorderAssortmentProductsSchema = {
   sortKeys: z
     .array(ReorderAssortmentProductInputSchema)
     .min(1)
-    .describe('New sort order for assortment products'),
+    .describe('Array of assortmentProductId with their new sort keys'),
 };
 
 export const ReorderAssortmentProductsZodSchema = z.object(ReorderAssortmentProductsSchema);
@@ -26,7 +26,7 @@ export async function reorderAssortmentProductsHandler(
   const { modules, userId } = context;
 
   try {
-    log('handler reorderAssortmentProducts', { userId, sortKeys });
+    log('handler reorderAssortmentProductsHandler', { userId, params });
 
     await modules.assortments.products.updateManualOrder({
       sortKeys,

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

@@ -6,11 +6,24 @@ export const SearchAssortmentProductSchema = {
   assortmentId: z.string().min(1).describe('ID of the assortment to search in'),
   queryString: z.string().optional().describe('Search query string'),
   filterQuery: z
-    .array(z.object({ key: z.string(), value: z.string().optional() }))
+    .array(
+      z.object({
+        key: z.string().describe('Filter key'),
+        value: z.string().optional().describe('Optional filter value'),
+      }),
+    )
     .optional()
     .describe('Filter conditions'),
-  includeInactive: z.boolean().optional().default(true),
-  ignoreChildAssortments: z.boolean().optional().default(false),
+  includeInactive: z
+    .boolean()
+    .optional()
+    .default(true)
+    .describe('Whether to include inactive products in search results'),
+  ignoreChildAssortments: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe('Whether to ignore child assortments during search'),
   limit: z.number().int().min(1).max(100).default(20).describe('Pagination limit'),
   offset: z.number().int().min(0).default(0).describe('Pagination offset'),
 };
@@ -27,7 +40,7 @@ export async function searchAssortmentProductHandler(
   const { assortmentId, limit, offset, ...query } = params;
 
   try {
-    log('handler searchAssortmentProduct', { userId, params });
+    log('handler searchAssortmentProductHandler', { userId, params });
 
     const productIds = await modules.assortments.findProductIds({
       assortmentId,

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

@@ -16,7 +16,7 @@ export async function setBaseAssortmentHandler(context: Context, params: SetBase
   const { assortmentId } = params;
 
   try {
-    log('handler setBaseAssortment', { userId, assortmentId });
+    log('handler setBaseAssortmentHandler', { userId, params });
 
     if (!(await modules.assortments.assortmentExists({ assortmentId })))
       throw new AssortmentNotFoundError({ assortmentId });

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'),
@@ -20,7 +21,13 @@ export async function translatedAssortmentMediaTextsHandler(
   const { modules, userId } = context;
 
   try {
-    log('handler translatedAssortmentMediaTexts', { userId, assortmentMediaId });
+    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/translatedAssortmentTextsHandler.ts

@@ -18,7 +18,7 @@ export async function translatedAssortmentTextsHandler(
   const { modules, userId } = context;
 
   try {
-    log('handler translatedAssortmentTexts', { userId, assortmentId });
+    log('handler translatedAssortmentTextsHandler', { userId, params });
 
     const texts = await modules.assortments.texts.findTexts({ assortmentId });
 

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

@@ -34,7 +34,7 @@ export async function updateAssortmentHandler(context: Context, params: UpdateAs
   const { assortmentId, assortment } = params;
 
   try {
-    log('handler updateAssortment', { userId, params });
+    log('handler updateAssortmentHandler', { userId, params });
 
     if (!(await modules.assortments.assortmentExists({ assortmentId })))
       throw new AssortmentNotFoundError({ assortmentId });

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

@@ -31,7 +31,7 @@ export async function updateAssortmentMediaTextsHandler(
   const { modules, userId } = context;
 
   try {
-    log('handler updateAssortmentMediaTexts', { userId, assortmentMediaId, texts });
+    log('handler updateAssortmentMediaTextsHandler', { userId, params });
 
     const assortmentMedia = await modules.assortments.media.findAssortmentMedia({
       assortmentMediaId,
@@ -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/assortment/updateAssortmentTextsHandler.ts

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
+import { AssortmentNotFoundError } from '../../../errors.js';
+
+export const AssortmentAssortmentTextInputSchema = z.object({
+  locale: z
+    .string()
+    .min(2)
+    .describe(
+      `Locale ISO code for the language of the text (e.g., "en-US", "de-CH").
+If not provided, fallback to the shop's defaultLanguageIsoCode.
+If provided, it must be a valid language configured in the shop.`,
+    ),
+  slug: z
+    .string()
+    .optional()
+    .describe('Optional URL-safe identifier for the assortment (e.g., "summer-sale").'),
+  title: z.string().optional().describe('Optional title for the assortment in this locale.'),
+  subtitle: z.string().optional().describe('Optional subtitle providing extra context.'),
+  description: z.string().optional().describe('Optional long-form description of the assortment.'),
+});
+
+export const UpdateAssortmentTextsSchema = {
+  assortmentId: z.string().min(1).describe('ID of the assortment to update'),
+  texts: z.array(AssortmentAssortmentTextInputSchema).min(1).describe('Localized metadata to update'),
+};
+
+export const UpdateAssortmentTextsZodSchema = z.object(UpdateAssortmentTextsSchema);
+
+export type UpdateAssortmentTextsParams = z.infer<typeof UpdateAssortmentTextsZodSchema>;
+
+export async function updateAssortmentTextsHandler(
+  context: Context,
+  params: UpdateAssortmentTextsParams,
+) {
+  const { assortmentId, texts } = params;
+  const { modules, userId } = context;
+
+  try {
+    log('handler updateAssortmentTextsHandler', { userId, params });
+
+    if (!(await modules.assortments.assortmentExists({ assortmentId })))
+      throw new AssortmentNotFoundError({ assortmentId });
+
+    const assortmentTexts = await modules.assortments.texts.updateTexts(assortmentId, texts as any);
+
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: JSON.stringify({ texts: assortmentTexts }),
+        },
+      ],
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: 'text' as const,
+          text: `Error updating assortment texts: ${(error as Error).message}`,
+        },
+      ],
+    };
+  }
+}

package/src/mcp/tools/country/countriesCountHandler.ts

@@ -7,22 +7,24 @@ export const CountriesCountSchema = {
     .boolean()
     .optional()
     .default(false)
-    .describe('Whether to include inactive countries in the count'),
-  queryString: z.string().optional().describe('Optional text search filter'),
+    .describe('If true, include inactive countries in the count. Defaults to false.'),
+  queryString: z
+    .string()
+    .optional()
+    .describe('Optional search string to filter countries by name or code'),
 };
 
 export const CountriesCountZodSchema = z.object(CountriesCountSchema);
 
 export type CountriesCountParams = z.infer<typeof CountriesCountZodSchema>;
 
-// Handler function
 export async function countriesCountHandler(context: Context, params: CountriesCountParams) {
-  const { includeInactive = false, queryString } = params;
   const { modules, userId } = context;
 
   try {
-    log(`query countriesCount (includeInactive: ${includeInactive}, query: ${queryString || ''})`, {
+    log(`handler countriesCountHandler`, {
       userId,
+      params,
     });
 
     const count = await modules.countries.count(params);

package/src/mcp/tools/country/countriesHandler.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { SortDirection } from '@unchainedshop/utils';
+import { log } from '@unchainedshop/logger';
 
 const sortDirectionKeys = Object.keys(SortDirection) as [
   keyof typeof SortDirection,
@@ -8,18 +9,37 @@ const sortDirectionKeys = Object.keys(SortDirection) as [
 ];
 
 export const ListCountriesSchema = {
-  limit: z.number().int().min(1).max(100).default(50),
-  offset: z.number().int().min(0).default(0),
-  includeInactive: z.boolean().default(false),
-  queryString: z.string().min(1).optional(),
+  limit: z
+    .number()
+    .int()
+    .min(1)
+    .max(100)
+    .default(50)
+    .describe('Maximum number of countries to return (pagination limit)'),
+  offset: z
+    .number()
+    .int()
+    .min(0)
+    .default(0)
+    .describe('Number of countries to skip before starting to collect the result set'),
+  includeInactive: z
+    .boolean()
+    .default(false)
+    .describe('Whether to include inactive (disabled) countries in the results'),
+  queryString: z
+    .string()
+    .min(1)
+    .optional()
+    .describe('Optional case-insensitive text filter to search country name or code'),
   sort: z
     .array(
       z.object({
-        key: z.string().min(1),
-        value: z.enum(sortDirectionKeys).describe("Sort direction, e.g., 'ASC' or 'DESC'"),
+        key: z.string().min(1).describe('Field name to sort by (e.g., "name", "isoCode")'),
+        value: z.enum(sortDirectionKeys).describe('Sorting direction, either "ASC" or "DESC"'),
       }),
     )
-    .optional(),
+    .optional()
+    .describe('List of fields and their corresponding sort directions'),
 };
 
 export const ListCountriesZodSchema = z.object(ListCountriesSchema);
@@ -28,9 +48,13 @@ export type ListCountriesParams = z.infer<typeof ListCountriesZodSchema>;
 
 export async function countriesHandler(context: Context, params: ListCountriesParams) {
   const { limit, offset, includeInactive, queryString, sort } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log(`handler countriesHandler`, {
+      userId,
+      params,
+    });
     const countries = await modules.countries.findCountries({
       limit,
       offset,

package/src/mcp/tools/country/countryHandler.ts

@@ -1,9 +1,10 @@
 import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { CountryNotFoundError } from '../../../errors.js';
+import { log } from '@unchainedshop/logger';
 
 export const CountrySchema = {
-  countryId: z.string().min(1).describe('The ID of the country to fetch'),
+  countryId: z.string().min(1).describe('ID of the country to retrieve'),
 };
 
 export const CountryZodSchema = z.object(CountrySchema);
@@ -12,9 +13,13 @@ export type CountryParams = z.infer<typeof CountryZodSchema>;
 
 export async function countryHandler(context: Context, params: CountryParams) {
   const { countryId } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log(`handler countryHandler`, {
+      userId,
+      params,
+    });
     const country = await modules.countries.findCountry({ countryId });
 
     if (!country) throw new CountryNotFoundError({ countryId });

package/src/mcp/tools/country/createCountryHandler.ts

@@ -20,7 +20,7 @@ export async function createCountryHandler(context: Context, params: CreateCount
   const { country } = params;
   const { modules, userId } = context;
   try {
-    log(`handler createCountry: ${country.isoCode}`, { userId });
+    log(`handler createCountryHandler`, { userId, params });
 
     const countryId = await modules.countries.create(country as any);
 

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

@@ -0,0 +1,46 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Context } from '../../../context.js';
+import { CountriesCountSchema, countriesCountHandler } from './countriesCountHandler.js';
+import { ListCountriesSchema, countriesHandler } from './countriesHandler.js';
+import { CountrySchema, countryHandler } from './countryHandler.js';
+import { CreateCountrySchema, createCountryHandler } from './createCountryHandler.js';
+import { RemoveCountrySchema, removeCountryHandler } from './removeCountryHandler.js';
+import { UpdateCountrySchema, updateCountryHandler } from './updateCountryHandler.js';
+
+export const registerCountryTools = (server: McpServer, context: Context) => {
+  server.tool(
+    'country_list',
+    'List countries with optional pagination, search, sorting, and inactive flag.',
+    ListCountriesSchema,
+    async (params) => countriesHandler(context, params),
+  );
+
+  server.tool('country_get', 'Retrieve a country by ID', CountrySchema, async (params) =>
+    countryHandler(context, params),
+  );
+
+  server.tool(
+    'country_create',
+    'Create a new country using its ISO 3166-1 alpha-2 code.',
+    CreateCountrySchema,
+    async (params) => createCountryHandler(context, params),
+  );
+
+  server.tool(
+    'country_update',
+    'Update details for a given country',
+    UpdateCountrySchema,
+    async (params) => updateCountryHandler(context, params),
+  );
+
+  server.tool('country_remove', 'Remove a country by its ID', RemoveCountrySchema, async (params) =>
+    removeCountryHandler(context, params),
+  );
+
+  server.tool(
+    'country_count',
+    'Return the number of countries, optionally filtered by search or inactive status.',
+    CountriesCountSchema,
+    async (params) => countriesCountHandler(context, params),
+  );
+};

package/src/mcp/tools/country/removeCountryHandler.ts

@@ -16,7 +16,7 @@ export async function removeCountryHandler(context: Context, params: RemoveCount
   const { modules, userId } = context;
 
   try {
-    log(`handler removeCountry: ${countryId}`, { userId });
+    log(`handler removeCountryHandler`, { userId, params });
 
     if (!(await modules.countries.countryExists({ countryId })))
       throw new CountryNotFoundError({ countryId });

package/src/mcp/tools/country/updateCountryHandler.ts

@@ -30,7 +30,7 @@ export async function updateCountryHandler(context: Context, params: UpdateCount
   const { country, countryId } = params;
   const { modules, userId } = context;
   try {
-    log(`handler updateCountry: ${countryId}`, { userId });
+    log(`handler updateCountryHandler`, { userId, params });
 
     if (!(await modules.countries.countryExists({ countryId })))
       throw new CountryNotFoundError({ countryId });

package/src/mcp/tools/currency/createCurrencyHandler.ts

@@ -9,14 +9,18 @@ export const CreateCurrencySchema = {
       .min(3)
       .max(3)
       .toUpperCase()
-      .describe('3-letter ISO currency code (e.g., "USD", "EUR", "CHF")'),
-    contractAddress: z.string().optional().describe('Blockchain contract address (optional)'),
+      .describe('3-letter ISO 4217 currency code (e.g., "USD", "EUR", "CHF")'),
+    contractAddress: z
+      .string()
+      .regex(/^0x[a-fA-F0-9]{40}$/, 'Must be a valid 42-character blockchain address')
+      .optional()
+      .describe('Optional blockchain contract address for the currency'),
     decimals: z
       .number()
       .int()
       .nonnegative()
       .optional()
-      .describe('Decimal precision for the currency (optional)'),
+      .describe('Optional decimal precision used by the currency (e.g., 2 for USD, 18 for ETH)'),
   }),
 };
 
@@ -28,7 +32,7 @@ export async function createCurrencyHandler(context: Context, params: CreateCurr
   const { modules, userId } = context;
 
   try {
-    log(`Handler createCurrency: ${currency.isoCode}`, { userId });
+    log(`Handler createCurrencyHandler`, { userId, params });
 
     const currencyId = await modules.currencies.create(currency as any);
 

package/src/mcp/tools/currency/currenciesCountHandler.ts

@@ -7,8 +7,8 @@ export const CurrenciesCountSchema = {
     .boolean()
     .optional()
     .default(false)
-    .describe('Include inactive currencies in count'),
-  queryString: z.string().optional().describe('Optional search filter'),
+    .describe('Whether to include inactive currencies in the count'),
+  queryString: z.string().optional().describe('Optional search string to filter currencies'),
 };
 
 export const CurrenciesCountZodSchema = z.object(CurrenciesCountSchema);
@@ -16,12 +16,11 @@ export const CurrenciesCountZodSchema = z.object(CurrenciesCountSchema);
 export type CurrenciesCountParams = z.infer<typeof CurrenciesCountZodSchema>;
 
 export async function currenciesCountHandler(context: Context, params: CurrenciesCountParams) {
-  const { includeInactive = false, queryString } = params;
   const { modules, userId } = context;
-
   try {
-    log(`Handler currenciesCount (includeInactive: ${includeInactive}, query: ${queryString ?? ''})`, {
+    log(`handler currenciesCountHandler`, {
       userId,
+      params,
     });
 
     const count = await modules.currencies.count(params);

package/src/mcp/tools/currency/currenciesHandler.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { SortDirection } from '@unchainedshop/utils';
+import { log } from '@unchainedshop/logger';
 
 const sortDirectionKeys = Object.keys(SortDirection) as [
   keyof typeof SortDirection,
@@ -8,18 +9,22 @@ const sortDirectionKeys = Object.keys(SortDirection) as [
 ];
 
 export const ListCurrenciesSchema = {
-  limit: z.number().int().min(1).max(100).default(50),
-  offset: z.number().int().min(0).default(0),
-  includeInactive: z.boolean().default(false),
-  queryString: z.string().min(1).optional(),
+  limit: z.number().int().min(1).max(100).default(50).describe('Maximum number of currencies to return'),
+  offset: z.number().int().min(0).default(0).describe('Number of currencies to skip (for pagination)'),
+  includeInactive: z
+    .boolean()
+    .default(false)
+    .describe('Whether to include inactive currencies in the results'),
+  queryString: z.string().min(1).optional().describe('Optional text search to filter currencies'),
   sort: z
     .array(
       z.object({
-        key: z.string().min(1),
-        value: z.enum(sortDirectionKeys).describe("Sort direction, e.g., 'ASC' or 'DESC'"),
+        key: z.string().min(1).describe('Field to sort by'),
+        value: z.enum(sortDirectionKeys).describe("Sort direction, either 'ASC' or 'DESC'"),
       }),
     )
-    .optional(),
+    .optional()
+    .describe('Sorting configuration'),
 };
 
 export const ListCurrenciesZodSchema = z.object(ListCurrenciesSchema);
@@ -29,9 +34,13 @@ export type ListCurrenciesParams = z.infer<typeof ListCurrenciesZodSchema>;
 export async function currenciesHandler(context: Context, params: ListCurrenciesParams) {
   const { limit, offset, includeInactive, queryString, sort } = params;
 
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log(`handler currenciesHandler`, {
+      userId,
+      params,
+    });
     const currencies = await modules.currencies.findCurrencies({
       limit,
       offset,

package/src/mcp/tools/currency/currencyHandler.ts

@@ -1,9 +1,10 @@
 import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { CurrencyNotFoundError } from '../../../errors.js';
+import { log } from '@unchainedshop/logger';
 
 export const CurrencySchema = {
-  currencyId: z.string().min(1).describe('The ID of the currency to fetch'),
+  currencyId: z.string().min(1).describe('The unique ID of the currency to retrieve'),
 };
 
 export const CurrencyZodSchema = z.object(CurrencySchema);
@@ -12,9 +13,13 @@ export type CurrencyParams = z.infer<typeof CurrencyZodSchema>;
 
 export async function currencyHandler(context: Context, params: CurrencyParams) {
   const { currencyId } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log(`handler currencyHandler`, {
+      userId,
+      params,
+    });
     const currency = await modules.currencies.findCurrency({ currencyId });
 
     if (!currency) throw new CurrencyNotFoundError({ currencyId });