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

package/src/mcp/tools/filter/createFilterOptionHandler.ts

@@ -12,14 +12,20 @@ export const FilterOptionTextInputSchema = z.object({
     .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(),
-  subtitle: z.string().optional(),
+  title: z.string().optional().describe('Optional localized title for the filter option'),
+  subtitle: z.string().optional().describe('Optional localized subtitle for the filter option'),
 });
 
 export const CreateFilterOptionSchema = {
-  filterId: z.string().min(1).describe('ID of the filter to add the option to'),
-  option: z.string().min(1).describe('Value of the new filter option'),
-  texts: z.array(FilterOptionTextInputSchema).optional().describe('Localized titles and subtitles'),
+  filterId: z
+    .string()
+    .min(1)
+    .describe('Unique identifier of the filter to which the option will be added'),
+  option: z.string().min(1).describe('Value of the new option to be added to the filter'),
+  texts: z
+    .array(FilterOptionTextInputSchema)
+    .optional()
+    .describe('Localized titles and subtitles for the filter option'),
 };
 
 export const CreateFilterOptionZodSchema = z.object(CreateFilterOptionSchema);
@@ -31,7 +37,7 @@ export async function createFilterOptionHandler(context: Context, params: Create
   const { modules, userId } = context;
 
   try {
-    log('handler createFilterOption', { userId, filterId, option, texts });
+    log('handler createFilterOptionHandler', { userId, params });
 
     const filter = await getNormalizedFilterDetails(filterId, context);
     if (!filter) throw new FilterNotFoundError({ filterId });

package/src/mcp/tools/filter/getFilterHandler.ts

@@ -5,7 +5,7 @@ import { FilterNotFoundError } from '../../../errors.js';
 import { getNormalizedFilterDetails } from '../../utils/getNormalizedFilterDetails.js';
 
 export const GetFilterSchema = {
-  filterId: z.string().min(1).describe('ID of the filter to retrieve'),
+  filterId: z.string().min(1).describe('Unique ID of the filter to retrieve details for'),
 };
 
 export const GetFilterZodSchema = z.object(GetFilterSchema);
@@ -17,7 +17,7 @@ export async function getFilterHandler(context: Context, params: GetFilterParams
   const { userId } = context;
 
   try {
-    log('handler getFilter', { userId, filterId });
+    log('handler getFilterHandler', { userId, params });
 
     const filter = await getNormalizedFilterDetails(filterId, context);
 

package/src/mcp/tools/filter/getFiltersHandler.ts

@@ -4,16 +4,16 @@ import { log } from '@unchainedshop/logger';
 import { getNormalizedFilterDetails } from '../../utils/getNormalizedFilterDetails.js';
 
 const SortOptionInputSchema = z.object({
-  key: z.string().min(1).describe('Field to sort by'),
-  value: z.enum(['ASC', 'DESC']).describe('Sort direction'),
+  key: z.string().min(1).describe('Field key to sort by (e.g., "key", "createdAt")'),
+  value: z.enum(['ASC', 'DESC']).describe('Sort direction: ASC for ascending, DESC for descending'),
 });
 
 export const GetFiltersSchema = {
-  limit: z.number().min(1).max(100).default(20),
-  offset: z.number().min(0).default(0),
-  includeInactive: z.boolean().default(false),
-  queryString: z.string().optional(),
-  sort: z.array(SortOptionInputSchema).optional(),
+  limit: z.number().min(1).max(100).default(20).describe('Maximum number of filters to return'),
+  offset: z.number().min(0).default(0).describe('Number of filters to skip (for pagination)'),
+  includeInactive: z.boolean().default(false).describe('Include inactive filters in the result'),
+  queryString: z.string().optional().describe('Free-text search filter (e.g., part of key or title)'),
+  sort: z.array(SortOptionInputSchema).optional().describe('List of sort options to order the filters'),
 };
 
 export const GetFiltersZodSchema = z.object(GetFiltersSchema);
@@ -21,17 +21,12 @@ export const GetFiltersZodSchema = z.object(GetFiltersSchema);
 export type GetFiltersParams = z.infer<typeof GetFiltersZodSchema>;
 
 export async function getFiltersHandler(context: Context, params: GetFiltersParams) {
-  const { limit, offset, includeInactive, queryString, sort } = params;
   const { modules, userId } = context;
 
   try {
-    log('handler getFilters', {
+    log('handler getFiltersHandler', {
       userId,
-      limit,
-      offset,
-      includeInactive,
-      queryString,
-      sort,
+      params,
     });
 
     const filters = await modules.filters.findFilters(params as any);

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

@@ -0,0 +1,74 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Context } from '../../../context.js';
+import { createFilterHandler, CreateFilterSchema } from './createFilterHandler.js';
+import { updateFilterHandler, UpdateFilterSchema } from './updateFilterHandler.js';
+import { removeFilterHandler, RemoveFilterSchema } from './removeFilterHandler.js';
+import { createFilterOptionHandler, CreateFilterOptionSchema } from './createFilterOptionHandler.js';
+import { updateFilterTextsHandler, UpdateFilterTextsSchema } from './updateFilterTextsHandler.js';
+import { removeFilterOptionHandler, RemoveFilterOptionSchema } from './removeFilterOptionHandler.js';
+import { getFilterHandler, GetFilterSchema } from './getFilterHandler.js';
+import { getFiltersHandler, GetFiltersSchema } from './getFiltersHandler.js';
+import {
+  translatedFilterTextsHandler,
+  TranslatedFilterTextsSchema,
+} from './translatedFilterTextsHandler.js';
+
+export const registerFilterTools = (server: McpServer, context: Context) => {
+  server.tool(
+    'filter_create',
+    'Create a new product filter with optional localized titles and subtitles.',
+    CreateFilterSchema,
+    async (params) => createFilterHandler(context, params),
+  );
+  server.tool(
+    'filter_update',
+    'Update a filter by ID with optional changes to key or activation status.',
+    UpdateFilterSchema,
+    async (params) => updateFilterHandler(context, params),
+  );
+
+  server.tool(
+    'filter_remove',
+    'Remove a filter by its ID, including any associated assortment references.',
+    RemoveFilterSchema,
+    async (params) => removeFilterHandler(context, params),
+  );
+  server.tool(
+    'filter_option_create',
+    'Create a new option under a given filter with optional localized titles and subtitles.',
+    CreateFilterOptionSchema,
+    async (params) => createFilterOptionHandler(context, params),
+  );
+
+  server.tool(
+    'filter_updateTexts',
+    'Update localized texts for a filter or one of its options.',
+    UpdateFilterTextsSchema,
+    async (params) => updateFilterTextsHandler(context, params),
+  );
+
+  server.tool(
+    'filter_option_remove',
+    'Remove a specific option from a filter by its value.',
+    RemoveFilterOptionSchema,
+    async (params) => removeFilterOptionHandler(context, params),
+  );
+
+  server.tool('filter_get', 'Retrieve details of a filter by its ID.', GetFilterSchema, async (params) =>
+    getFilterHandler(context, params),
+  );
+
+  server.tool(
+    'filter_list',
+    'List filters with optional pagination, query string, and sorting. Can include inactive ones.',
+    GetFiltersSchema,
+    async (params) => getFiltersHandler(context, params),
+  );
+
+  server.tool(
+    'filter_getTexts',
+    'Retrieve translated texts for a filter or a specific filter option.',
+    TranslatedFilterTextsSchema,
+    async (params) => translatedFilterTextsHandler(context, params),
+  );
+};

package/src/mcp/tools/filter/removeFilterHandler.ts

@@ -5,7 +5,7 @@ import { FilterNotFoundError } from '../../../errors.js';
 import { getNormalizedFilterDetails } from '../../utils/getNormalizedFilterDetails.js';
 
 export const RemoveFilterSchema = {
-  filterId: z.string().min(1).describe('ID of the filter to remove'),
+  filterId: z.string().min(1).describe('Unique identifier of the filter to be removed'),
 };
 
 export const RemoveFilterZodSchema = z.object(RemoveFilterSchema);
@@ -17,7 +17,7 @@ export async function removeFilterHandler(context: Context, params: RemoveFilter
   const { modules, userId } = context;
 
   try {
-    log(`handler removeFilter: ${filterId}`, { userId });
+    log(`handler removeFilterHandler`, { userId, params });
 
     const filter = await getNormalizedFilterDetails(filterId, context);
     if (!filter) throw new FilterNotFoundError({ filterId });

package/src/mcp/tools/filter/removeFilterOptionHandler.ts

@@ -6,8 +6,8 @@ import { getNormalizedFilterDetails } from '../../utils/getNormalizedFilterDetai
 import { FilterDirector } from '@unchainedshop/core';
 
 export const RemoveFilterOptionSchema = {
-  filterId: z.string().min(1).describe('ID of the filter to remove option from'),
-  filterOptionValue: z.string().min(1).describe('Value of the option to remove'),
+  filterId: z.string().min(1).describe('Unique identifier of the filter to modify'),
+  filterOptionValue: z.string().min(1).describe('Exact value of the filter option to remove'),
 };
 
 export const RemoveFilterOptionZodSchema = z.object(RemoveFilterOptionSchema);
@@ -19,7 +19,7 @@ export async function removeFilterOptionHandler(context: Context, params: Remove
   const { modules, userId } = context;
 
   try {
-    log('handler removeFilterOption', { userId, filterId, filterOptionValue });
+    log('handler removeFilterOptionHandler', { userId, params });
     const filter = await getNormalizedFilterDetails(filterId, context);
     if (!filter) throw new FilterNotFoundError({ filterId });
 

package/src/mcp/tools/filter/translatedFilterTextsHandler.ts

@@ -4,8 +4,14 @@ import { log } from '@unchainedshop/logger';
 import { FilterNotFoundError } from '../../../errors.js';
 
 export const TranslatedFilterTextsSchema = {
-  filterId: z.string().min(1).describe('ID of the filter to fetch texts for'),
-  filterOptionValue: z.string().optional().describe('Optional option value to fetch texts for'),
+  filterId: z
+    .string()
+    .min(1)
+    .describe('Unique identifier of the filter to retrieve translated texts for'),
+  filterOptionValue: z
+    .string()
+    .optional()
+    .describe('Optional: specific filter option value to fetch translated texts for'),
 };
 
 export const TranslatedFilterTextsZodSchema = z.object(TranslatedFilterTextsSchema);
@@ -20,7 +26,7 @@ export async function translatedFilterTextsHandler(
   const { modules, userId } = context;
 
   try {
-    log('handler translatedFilterTexts', { userId, filterId, filterOptionValue });
+    log('handler translatedFilterTextsHandler', { userId, params });
 
     const filter = await modules.filters.findFilter({ filterId });
     if (!filter) {

package/src/mcp/tools/filter/updateFilterHandler.ts

@@ -6,13 +6,13 @@ import { FilterDirector } from '@unchainedshop/core';
 import { getNormalizedFilterDetails } from '../../utils/getNormalizedFilterDetails.js';
 
 export const UpdateFilterInputSchema = z.object({
-  isActive: z.boolean().optional(),
-  key: z.string().min(1).optional(),
+  isActive: z.boolean().optional().describe('Whether the filter should be active or not'),
+  key: z.string().min(1).optional().describe('New unique key for the filter (if updating)'),
 });
 
 export const UpdateFilterSchema = {
   filterId: z.string().min(1).describe('ID of the filter to update'),
-  filter: UpdateFilterInputSchema,
+  filter: UpdateFilterInputSchema.describe('Filter fields to update'),
 };
 
 export const UpdateFilterZodSchema = z.object(UpdateFilterSchema);
@@ -24,7 +24,7 @@ export async function updateFilterHandler(context: Context, params: UpdateFilter
   const { modules, userId } = context;
 
   try {
-    log('handler updateFilter', { userId, filterId, filter });
+    log('handler updateFilterHandler', { userId, params });
     if (!(await modules.filters.filterExists({ filterId }))) throw new FilterNotFoundError({ filterId });
 
     const updatedFilter = await modules.filters.update(filterId, filter as any);

package/src/mcp/tools/filter/updateFilterTextsHandler.ts

@@ -5,15 +5,24 @@ import { FilterNotFoundError } from '../../../errors.js';
 import { getNormalizedFilterDetails } from '../../utils/getNormalizedFilterDetails.js';
 
 export const FilterUpdateTextInputSchema = z.object({
-  locale: z.string().min(1),
-  title: z.string().optional(),
-  subtitle: z.string().optional(),
+  locale: z.string().min(1).describe('Locale ISO code (e.g., "en-US", "de-CH")'),
+  title: z.string().optional().describe('Title for the filter or filter option in the specified locale'),
+  subtitle: z
+    .string()
+    .optional()
+    .describe('Subtitle for the filter or filter option in the specified locale'),
 });
 
 export const UpdateFilterTextsSchema = {
-  filterId: z.string().min(1).describe('ID of the filter to update texts for'),
-  filterOptionValue: z.string().optional().describe('Optional filter option to localize'),
-  texts: z.array(FilterUpdateTextInputSchema).min(1).describe('Localized texts to create or update'),
+  filterId: z.string().min(1).describe('ID of the filter to update localized texts for'),
+  filterOptionValue: z
+    .string()
+    .optional()
+    .describe('Optional value of the filter option to localize (if applicable)'),
+  texts: z
+    .array(FilterUpdateTextInputSchema)
+    .min(1)
+    .describe('Array of localized texts to set or update'),
 };
 
 export const UpdateFilterTextsZodSchema = z.object(UpdateFilterTextsSchema);

package/src/mcp/tools/index.ts

@@ -1,89 +1,12 @@
-/**
- * Re-export all MCP tools
- */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Context } from '../../context.js';
+import { shopInfoHandler } from './shopInfoHandler.js';
 
-export * from './product/listProducts.js';
-export * from './product/getProduct.js';
-export * from './product/createProductHandler.js';
-export * from './product/removeProductHandler.js';
-export * from './product/publishProduct.js';
-export * from './product/unPublishProduct.js';
-export * from './product/updateProduct.js';
-export * from './product/updateProductTextsHandler.js';
-export * from './product/updateProductCommerceHandler.js';
-export * from './product/updateProductSupplyHandler.js';
-export * from './product/updateProductWarehousingHandler.js';
-export * from './language/languagesCountHandler.js';
-export * from './language/languagesHandler.js';
-export * from './language/languageHandler.js';
-export * from './language/createLanguageHandler.js';
-export * from './language/updateLanguageHandler.js';
-export * from './language/removeLanguageHandler.js';
-export * from './product/updateProductPlanHandler.js';
-export * from './product/updateProductTokenizationHandler.js';
-export * from './product/productsCountHandler.js';
-export * from './product/createProductVariationHandler.js';
-export * from './product/removeProductVariationHandler.js';
-export * from './product/addProductAssignmentHandler.js';
-export * from './product/createProductVariationOptionHandler.js';
-export * from './product/removeProductAssignmentHandler.js';
-export * from './product/removeProductVariationOptionHandler.js';
-export * from './product/addProductMediaUploadHandler.js';
-export * from './product/removeProductMediaHandler.js';
-export * from './product/updateProductMediaTextsHandler.js';
-export * from './product/reorderProductMediaHandler.js';
-export * from './product/productReviewsCountHandler.js';
-export * from './product/productReviewsHandler.js';
-export * from './product/translatedProductTextsHandler.js';
-export * from './product/translatedProductMediaTextsHandler.js';
-export * from './product/translatedProductVariationTextsHandler.js';
-export * from './shopInfoHandler.js';
-export * from './country/countriesHandler.js';
-export * from './country/countryHandler.js';
-export * from './country/createCountryHandler.js';
-export * from './country/updateCountryHandler.js';
-export * from './country/removeCountryHandler.js';
-export * from './country/countriesCountHandler.js';
-export * from './currency/createCurrencyHandler.js';
-export * from './currency/updateCurrencyHandler.js';
-export * from './currency/removeCurrencyHandler.js';
-export * from './currency/currenciesCountHandler.js';
-export * from './currency/currenciesHandler.js';
-export * from './currency/currencyHandler.js';
-
-export * from './assortment/assortmentHandler.js';
-export * from './assortment/assortmentsHandler.js';
-export * from './assortment/assortmentsCountHandler.js';
-export * from './assortment/createAssortmentHandler.js';
-export * from './assortment/updateAssortmentHandler.js';
-export * from './assortment/removeAssortmentHandler.js';
-export * from './assortment/setBaseAssortmentHandler.js';
-export * from './assortment/assortmentChildrenHandler.js';
-export * from './assortment/assortmentProductsHandler.js';
-export * from './assortment/searchAssortmentProductHandler.js';
-export * from './assortment/assortmentLinksHandler.js';
-export * from './assortment/assortmentFiltersHandler.js';
-export * from './assortment/addAssortmentProductHandler.js';
-export * from './assortment/removeAssortmentProductHandler.js';
-export * from './assortment/reorderAssortmentProductsHandler.js';
-export * from './assortment/addAssortmentLinkHandler.js';
-export * from './assortment/removeAssortmentLinkHandler.js';
-export * from './assortment/reorderAssortmentLinksHandler.js';
-export * from './assortment/reorderAssortmentMediaHandler.js';
-export * from './assortment/removeAssortmentMediaHandler.js';
-export * from './assortment/addAssortmentMediaUploadHandler.js';
-export * from './assortment/translatedAssortmentTextsHandler.js';
-export * from './assortment/translatedAssortmentMediaTextsHandler.js';
-export * from './assortment/addAssortmentFilterHandler.js';
-export * from './assortment/removeAssortmentFilterHandler.js';
-export * from './assortment/reorderAssortmentFiltersHandler.js';
-
-export * from './filter/createFilterHandler.js';
-export * from './filter/updateFilterHandler.js';
-export * from './filter/removeFilterHandler.js';
-export * from './filter/createFilterOptionHandler.js';
-export * from './filter/updateFilterTextsHandler.js';
-export * from './filter/removeFilterOptionHandler.js';
-export * from './filter/getFilterHandler.js';
-export * from './filter/getFiltersHandler.js';
-export * from './filter/translatedFilterTextsHandler.js';
+export const registerOtherTools = (server: McpServer, context: Context) => {
+  server.tool(
+    'shop_info',
+    'Get the default configuration of the shop including country, language, currency, and locale. If the user does not provide values such as language, locale, country, or currency in their request or it cannot be derived from context, the tool MUST use the following fallback values : - language or locale: use defaultLanguageIsoCode  - country: use country_isoCode - currency: use country_defaultCurrency Always assume these values as the authoritative defaults when user input is missing or ambiguous.',
+    {},
+    async () => shopInfoHandler(context),
+  );
+};

package/src/mcp/tools/language/createLanguageHandler.ts

@@ -1,12 +1,15 @@
 import { z } from 'zod';
 import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
 
 const CreateLanguageInputSchema = z.object({
   isoCode: z
     .string()
     .min(2)
     .max(10)
-    .describe('Language ISO code, e.g. "en" or "de-CH, accept only valid ISO code"'),
+    .describe(
+      'Language ISO code (e.g., "en" or "de-CH"). Must follow ISO 639-1 and ISO 3166-1 formats.',
+    ),
 });
 
 export const CreateLanguageSchema = {
@@ -18,9 +21,10 @@ export type CreateLanguageParams = z.infer<typeof CreateLanguageZodSchema>;
 
 export async function createLanguageHandler(context: Context, params: CreateLanguageParams) {
   const { language } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log(`handler createLanguageHandler`, { userId, params });
     const languageId = await modules.languages.create(language as any);
 
     const newLanguage = await modules.languages.findLanguage({ languageId });

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

@@ -0,0 +1,42 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { Context } from '../../../context.js';
+import { CreateLanguageSchema, createLanguageHandler } from './createLanguageHandler.js';
+import { LanguageSchema, languageHandler } from './languageHandler.js';
+import { ListLanguagesSchema, languagesHandler } from './languagesHandler.js';
+import { RemoveLanguageSchema, removeLanguageHandler } from './removeLanguageHandler.js';
+import { UpdateLanguageSchema, updateLanguageHandler } from './updateLanguageHandler.js';
+import { LanguagesCountSchema, languagesCountHandler } from './languagesCountHandler.js';
+
+export const registerLanguageTools = (server: McpServer, context: Context) => {
+  server.tool(
+    'languages_list',
+    'List languages with optional filters, pagination, and sorting',
+    ListLanguagesSchema,
+    async (params) => languagesHandler(context, params),
+  );
+
+  server.tool('language_get', 'Fetch a specific language by ID.', LanguageSchema, async (params) =>
+    languageHandler(context, params),
+  );
+
+  server.tool(
+    'language_create',
+    'Create a new language using an ISO code like "en" or "de-CH".',
+    CreateLanguageSchema,
+    async (params) => createLanguageHandler(context, params),
+  );
+
+  server.tool('update_language', 'Update language details', UpdateLanguageSchema, async (params) =>
+    updateLanguageHandler(context, params),
+  );
+
+  server.tool('language_remove', 'Remove a language by its ID', RemoveLanguageSchema, async (params) =>
+    removeLanguageHandler(context, params),
+  );
+  server.tool(
+    'language_count',
+    'Return the count of languages, optionally including inactive and filtering by search text.',
+    LanguagesCountSchema,
+    async (params) => languagesCountHandler(context, params),
+  );
+};

package/src/mcp/tools/language/languageHandler.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { Context } from '../../../context.js';
+import { log } from '@unchainedshop/logger';
 
 export const LanguageSchema = {
   languageId: z.string().min(1).describe('The ID of the language to fetch'),
@@ -11,9 +12,10 @@ export type LanguageParams = z.infer<typeof LanguageZodSchema>;
 
 export async function languageHandler(context: Context, params: LanguageParams) {
   const { languageId } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log(`handler languageHandler`, { userId, params });
     const language = await modules.languages.findLanguage({ languageId });
 
     return {

package/src/mcp/tools/language/languagesCountHandler.ts

@@ -12,12 +12,12 @@ export const LanguagesCountZodSchema = z.object(LanguagesCountSchema);
 export type LanguagesCountParams = z.infer<typeof LanguagesCountZodSchema>;
 
 export async function languagesCountHandler(context: Context, params: LanguagesCountParams) {
-  const { includeInactive = false, queryString } = params;
   const { modules, userId } = context;
 
   try {
-    log(`handler languagesCount (includeInactive: ${includeInactive}, query: ${queryString ?? ''})`, {
+    log(`handler languagesCountHandler `, {
       userId,
+      params,
     });
 
     const count = await modules.languages.count(params);

package/src/mcp/tools/language/languagesHandler.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,19 @@ const sortDirectionKeys = Object.keys(SortDirection) as [
 ];
 
 export const ListLanguagesSchema = {
-  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 languages to return'),
+  offset: z.number().int().min(0).default(0).describe('Number of languages to skip for pagination'),
+  includeInactive: z.boolean().default(false).describe('Whether to include inactive languages'),
+  query_string: z.string().min(1).optional().describe('Optional text search filter'),
   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, 'ASC' or 'DESC'"),
       }),
     )
-    .optional(),
+    .optional()
+    .describe('Sort configuration'),
 };
 
 export const ListLanguagesZodSchema = z.object(ListLanguagesSchema);
@@ -27,11 +29,14 @@ export const ListLanguagesZodSchema = z.object(ListLanguagesSchema);
 export type ListLanguagesParams = z.infer<typeof ListLanguagesZodSchema>;
 
 export async function languagesHandler(context: Context, params: ListLanguagesParams) {
-  const { sort, ...restParams } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
-    const languages = await modules.languages.findLanguages({ ...restParams, sort: sort as any[] });
+    log(`handler languagesHandler `, {
+      userId,
+      params,
+    });
+    const languages = await modules.languages.findLanguages(params as any);
 
     return {
       content: [

package/src/mcp/tools/language/removeLanguageHandler.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { LanguageNotFoundError } from '../../../errors.js';
+import { log } from '@unchainedshop/logger';
 
 export const RemoveLanguageSchema = {
   languageId: z.string().min(1).describe('ID of the language to remove'),
@@ -11,9 +12,13 @@ export type RemoveLanguageParams = z.infer<typeof RemoveLanguageZodSchema>;
 
 export async function removeLanguageHandler(context: Context, params: RemoveLanguageParams) {
   const { languageId } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log(`handler languagesHandler `, {
+      userId,
+      params,
+    });
     if (!(await modules.languages.languageExists({ languageId })))
       throw new LanguageNotFoundError({ languageId });
 

package/src/mcp/tools/language/updateLanguageHandler.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { Context } from '../../../context.js';
 import { LanguageNotFoundError } from '../../../errors.js';
+import { log } from '@unchainedshop/logger';
 
 const UpdateLanguageInputSchema = z.object({
   isoCode: z.string().min(2).max(10).describe('Updated ISO code for the language'),
@@ -17,9 +18,13 @@ export type UpdateLanguageParams = z.infer<typeof UpdateLanguageZodSchema>;
 
 export async function updateLanguageHandler(context: Context, params: UpdateLanguageParams) {
   const { languageId, language } = params;
-  const { modules } = context;
+  const { modules, userId } = context;
 
   try {
+    log(`handler updateLanguageHandler `, {
+      userId,
+      params,
+    });
     if (!(await modules.languages.languageExists({ languageId })))
       throw new LanguageNotFoundError({ languageId });