yazio-mcp 0.0.3 → 0.0.6

package/README.md

@@ -77,7 +77,7 @@ Easily log meals you forgot to track in the Yazio app directly from Claude or Cu
 ## Test Connection
 
 ```bash
-YAZIO_USERNAME=your_email YAZIO_PASSWORD=your_password npx yazio-mcp
+YAZIO_USERNAME='your_email' YAZIO_PASSWORD='your_password' npx yazio-mcp
 ```
 
 ## ⚠️ Important Disclaimers
@@ -92,6 +92,14 @@ YAZIO_USERNAME=your_email YAZIO_PASSWORD=your_password npx yazio-mcp
 - Valid Yazio account
 - MCP-compatible client (Claude Desktop, Cursor, etc.)
 
+# Development
+1. Download the repository
+2. Point to local copy in your mcp config
+3. Debugging:
+
+```
+YAZIO_USERNAME=X YAZIO_PASSWORD=X npx -y @modelcontextprotocol/inspector npx <local-path>/yazio-mcp
+```
 ---
 
 ## 📄 License

package/dist/index.js

@@ -1,23 +1,19 @@
 #!/usr/bin/env node
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
 import { Yazio } from 'yazio';
-import { zodToJsonSchema } from 'zod-to-json-schema';
-import { GetFoodEntriesInputSchema, GetDailySummaryInputSchema, GetUserInfoInputSchema, GetUserWeightInputSchema, GetWaterIntakeInputSchema, SearchProductsInputSchema, GetProductInputSchema, GetUserExercisesInputSchema, GetUserSettingsInputSchema, GetUserSuggestedProductsInputSchema, AddConsumedItemInputSchema, RemoveConsumedItemInputSchema, GetDietaryPreferencesInputSchema, GetUserGoalsInputSchema } from './schemas.js';
+import { v4 as uuidv4 } from "uuid";
+import { GetFoodEntriesInputSchema, GetDailySummaryInputSchema, GetUserInfoInputSchema, GetUserWeightInputSchema, GetWaterIntakeInputSchema, SearchProductsInputSchema, GetProductInputSchema, GetUserExercisesInputSchema, GetUserSettingsInputSchema, GetUserSuggestedProductsInputSchema, AddConsumedItemInputSchema, RemoveConsumedItemInputSchema, GetDietaryPreferencesInputSchema, GetUserGoalsInputSchema, } from './schemas.js';
 class YazioMcpServer {
     server;
     yazioClient = null;
     constructor() {
-        this.server = new Server({
+        this.server = new McpServer({
             name: 'yazio-mcp',
-            version: '0.0.2',
-        }, {
-            capabilities: {
-                tools: {},
-            },
+            version: '0.0.6',
         });
         this.setupToolHandlers();
+        this.setupPromptHandlers();
         this.setupErrorHandling();
         this.initializeClient();
     }
@@ -47,187 +43,241 @@ class YazioMcpServer {
         }
     }
     setupErrorHandling() {
-        this.server.onerror = (error) => console.error('[MCP Error]', error);
         process.on('SIGINT', async () => {
             await this.server.close();
             process.exit(0);
         });
     }
     setupToolHandlers() {
-        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-            tools: [
-                {
-                    name: 'get_product',
-                    description: 'Get detailed information about a specific product by ID',
-                    inputSchema: zodToJsonSchema(GetProductInputSchema),
-                    annotations: {
-                        readOnlyHint: true,
-                        idempotentHint: true,
-                        openWorldHint: true
-                    }
-                },
-                {
-                    name: 'get_user',
-                    description: 'Get Yazio user profile information',
-                    inputSchema: zodToJsonSchema(GetUserInfoInputSchema),
-                    annotations: {
-                        readOnlyHint: true,
-                        idempotentHint: true
-                    }
-                },
-                {
-                    name: 'get_user_consumed_items',
-                    description: 'Get food entries for a specific date',
-                    inputSchema: zodToJsonSchema(GetFoodEntriesInputSchema),
-                    annotations: {
-                        readOnlyHint: true,
-                        idempotentHint: true
-                    }
-                },
-                {
-                    name: 'get_user_dietary_preferences',
-                    description: 'Get user dietary preferences and restrictions',
-                    inputSchema: zodToJsonSchema(GetDietaryPreferencesInputSchema),
-                    annotations: {
-                        readOnlyHint: true,
-                        idempotentHint: true
-                    }
-                },
-                {
-                    name: 'get_user_exercises',
-                    description: 'Get user exercise data for a date or date range',
-                    inputSchema: zodToJsonSchema(GetUserExercisesInputSchema),
-                    annotations: {
-                        readOnlyHint: true,
-                        idempotentHint: true
-                    }
-                },
-                {
-                    name: 'get_user_goals',
-                    description: 'Get user nutrition and fitness goals',
-                    inputSchema: zodToJsonSchema(GetUserGoalsInputSchema),
-                    annotations: {
-                        readOnlyHint: true,
-                        idempotentHint: true
-                    }
-                },
-                {
-                    name: 'get_user_settings',
-                    description: 'Get user settings and preferences',
-                    inputSchema: zodToJsonSchema(GetUserSettingsInputSchema),
-                    annotations: {
-                        readOnlyHint: true,
-                        idempotentHint: true
-                    }
-                },
-                {
-                    name: 'get_user_suggested_products',
-                    description: 'Get product suggestions for the user',
-                    inputSchema: zodToJsonSchema(GetUserSuggestedProductsInputSchema),
-                    annotations: {
-                        readOnlyHint: true,
-                        idempotentHint: true,
-                        openWorldHint: true
-                    }
-                },
-                {
-                    name: 'get_user_water_intake',
-                    description: 'Get water intake data for a specific date',
-                    inputSchema: zodToJsonSchema(GetWaterIntakeInputSchema),
-                    annotations: {
-                        readOnlyHint: true,
-                        idempotentHint: true
-                    }
-                },
-                {
-                    name: 'get_user_weight',
-                    description: 'Get user weight data',
-                    inputSchema: zodToJsonSchema(GetUserWeightInputSchema),
-                    annotations: {
-                        readOnlyHint: true,
-                        idempotentHint: true
-                    }
-                },
-                {
-                    name: 'search_products',
-                    description: 'Search for food products in Yazio database',
-                    inputSchema: zodToJsonSchema(SearchProductsInputSchema),
-                    annotations: {
-                        readOnlyHint: true,
-                        idempotentHint: true,
-                        openWorldHint: true
-                    }
-                },
-                {
-                    name: 'get_user_daily_summary',
-                    description: 'Get daily nutrition summary for a specific date',
-                    inputSchema: zodToJsonSchema(GetDailySummaryInputSchema),
-                    annotations: {
-                        readOnlyHint: true,
-                        idempotentHint: true
-                    }
-                },
-                {
-                    name: 'add_user_consumed_item',
-                    description: 'Add a food item to user consumption log',
-                    inputSchema: zodToJsonSchema(AddConsumedItemInputSchema),
-                    annotations: {
-                        readOnlyHint: false,
-                        idempotentHint: false
+        this.server.registerTool('get_user', {
+            description: 'Get Yazio user profile information',
+            inputSchema: GetUserInfoInputSchema,
+            annotations: {
+                readOnlyHint: true,
+                idempotentHint: true,
+            },
+        }, async () => {
+            return await this.getUser();
+        });
+        this.server.registerTool('get_user_consumed_items', {
+            description: 'Get food entries for a specific date',
+            inputSchema: GetFoodEntriesInputSchema,
+            annotations: {
+                readOnlyHint: true,
+                idempotentHint: true,
+            },
+        }, async (args) => {
+            return await this.getUserConsumedItems(args);
+        });
+        this.server.registerTool('get_user_dietary_preferences', {
+            description: 'Get user dietary preferences and restrictions',
+            inputSchema: GetDietaryPreferencesInputSchema,
+            annotations: {
+                readOnlyHint: true,
+                idempotentHint: true,
+            },
+        }, async () => {
+            return await this.getUserDietaryPreferences();
+        });
+        this.server.registerTool('get_user_exercises', {
+            description: 'Get user exercise data for a date or date range',
+            inputSchema: GetUserExercisesInputSchema,
+            annotations: {
+                readOnlyHint: true,
+                idempotentHint: true,
+            },
+        }, async (args) => {
+            return await this.getUserExercises(args);
+        });
+        this.server.registerTool('get_user_goals', {
+            description: 'Get user nutrition and fitness goals',
+            inputSchema: GetUserGoalsInputSchema,
+            annotations: {
+                readOnlyHint: true,
+                idempotentHint: true,
+            },
+        }, async () => {
+            return await this.getUserGoals();
+        });
+        this.server.registerTool('get_user_settings', {
+            description: 'Get user settings and preferences',
+            inputSchema: GetUserSettingsInputSchema,
+            annotations: {
+                readOnlyHint: true,
+                idempotentHint: true,
+            },
+        }, async () => {
+            return await this.getUserSettings();
+        });
+        this.server.registerTool('get_user_suggested_products', {
+            description: 'Get product suggestions for the user',
+            inputSchema: GetUserSuggestedProductsInputSchema,
+            annotations: {
+                readOnlyHint: true,
+                idempotentHint: true,
+                openWorldHint: true,
+            },
+        }, async (args) => {
+            return await this.getUserSuggestedProducts(args);
+        });
+        this.server.registerTool('get_user_water_intake', {
+            description: 'Get water intake data for a specific date',
+            inputSchema: GetWaterIntakeInputSchema,
+            annotations: {
+                readOnlyHint: true,
+                idempotentHint: true,
+            },
+        }, async (args) => {
+            return await this.getUserWaterIntake(args);
+        });
+        this.server.registerTool('get_user_weight', {
+            description: 'Get user weight data',
+            inputSchema: GetUserWeightInputSchema,
+            annotations: {
+                readOnlyHint: true,
+                idempotentHint: true,
+            },
+        }, async () => {
+            return await this.getUserWeight();
+        });
+        this.server.registerTool('get_user_daily_summary', {
+            description: 'Get daily nutrition summary for a specific date',
+            inputSchema: GetDailySummaryInputSchema,
+            annotations: {
+                readOnlyHint: true,
+                idempotentHint: true,
+            },
+        }, async (args) => {
+            return await this.getUserDailySummary(args);
+        });
+        this.server.registerTool('search_products', {
+            description: 'Search for food products in Yazio database',
+            inputSchema: SearchProductsInputSchema,
+            // outputSchema: SearchProductsOutputSchema,
+            annotations: {
+                readOnlyHint: true,
+                idempotentHint: true,
+                openWorldHint: true,
+            },
+        }, async (args) => {
+            return await this.searchProducts(args);
+        });
+        this.server.registerTool('get_product', {
+            description: 'Get detailed information about a specific product by ID',
+            inputSchema: GetProductInputSchema,
+            annotations: {
+                readOnlyHint: true,
+                idempotentHint: true,
+                openWorldHint: true,
+            },
+        }, async (args) => {
+            return await this.getProduct(args);
+        });
+        this.server.registerTool('add_user_consumed_item', {
+            description: 'Add a food item to user consumption log',
+            inputSchema: AddConsumedItemInputSchema,
+            annotations: {
+                readOnlyHint: false,
+                idempotentHint: false,
+            },
+        }, async (args) => {
+            return await this.addUserConsumedItem(args);
+        });
+        this.server.registerTool('remove_user_consumed_item', {
+            description: 'Remove a food item from user consumption log',
+            inputSchema: RemoveConsumedItemInputSchema,
+            annotations: {
+                readOnlyHint: false,
+                destructiveHint: true,
+                idempotentHint: true,
+            },
+        }, async (args) => {
+            return await this.removeUserConsumedItem(args);
+        });
+    }
+    setupPromptHandlers() {
+        this.server.registerPrompt('add_food_item', {
+            title: 'Add Food Item to Log',
+            description: 'Guide for adding a food item to the user\'s consumption log',
+        }, async () => {
+            return {
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `To add a food item to the user's consumption log, follow these steps:
+
+1. **Search for the product**: Use the \`search_products\` tool with a query string (e.g., "chicken breast", "apple", "pasta"). This will return a list of matching products with their IDs.
+
+2. **Clarify the product**: If multiple products are found, ask the user to clarify which product they want to use.
+
+3. **Get product details**: Use the \`get_product\` tool with the \`product_id\` from the search results. This will show you:
+   - Available serving types (e.g., "portion", "gram", "piece", "cup") and their amounts in base units (g or ml)
+   - Base unit (g or ml)
+   - Full nutritional information
+
+4. **Clarify the serving**: If the user doesn't provide a serving type and quantity, ask them to clarify the serving type provided by previous step and quantity they want to add.
+
+5. **Add the consumed item**: Use the \`add_user_consumed_item\` tool with:
+   - \`product_id\`: The UUID from step 1
+   - \`date\`: Date in YYYY-MM-DD format
+   - \`daytime\`: One of: "breakfast", "lunch", "dinner", or "snack"
+   - \`serving\`: Use a serving type from step 2 (e.g., "portion", "piece", "cup") OR base unit (g or ml)
+   - \`serving_quantity\`: Quantity of the serving type (e.g., 1, 2, 0.5)
+   - \`amount\`: Direct amount in base units (g or ml). If serving type is provided, use the amount of the serving type * serving_quantity. If serving type is not provided, use the amount of the base unit.
+
+**Important Notes**:
+- Always search first if you don't have a product_id
+- Check product details to understand available serving types, base unit (g or ml) and amount in serving
+- The date should be in ISO format (YYYY-MM-DD)
+- You can use serving or base unit approach:
+  1. serving type + serving quantity + amount (amount for selected serving type multiplied by serving quantity)
+  2. amount in g/ml - serving fields could be omitted
+Example:
+  1. "I ate 2 apples" - serving type "piece" which has 100g amount (from product details) + serving quantity 2 + amount 200g
+  2. "I ate 200g of chicken breast" - amount 200g
+- Always provide amount in base units (g or ml), not in servings.
+`
+                        }
                     }
-                },
-                {
-                    name: 'remove_user_consumed_item',
-                    description: 'Remove a food item from user consumption log',
-                    inputSchema: zodToJsonSchema(RemoveConsumedItemInputSchema),
-                    annotations: {
-                        readOnlyHint: false,
-                        destructiveHint: true,
-                        idempotentHint: true
+                ]
+            };
+        });
+        this.server.registerPrompt('remove_food_item', {
+            title: 'Remove Food Item from Log',
+            description: 'Guide for removing a food item from the user\'s consumption log',
+        }, async () => {
+            return {
+                messages: [
+                    {
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `To remove a food item from the user's consumption log, follow these steps:
+
+1. **Get consumed items**: Use the \`get_user_consumed_items\` tool with the \`date\` parameter (in YYYY-MM-DD format) to retrieve all food entries for that date.
+
+2. **Identify the item**: From the returned list of consumed items, identify the specific item you want to remove. Each item will have:
+   - \`id\`: The unique identifier for the consumed item (this is what you need for removal)
+   - \`product_id\`: The product identifier
+   - \`name\`: The product name
+   - \`date\`: The date it was consumed
+   - \`daytime\`: The meal type (breakfast, lunch, dinner, snack)
+   - Other details like amount, serving, etc.
+
+3. **Remove the item**: Use the \`remove_user_consumed_item\` tool with:
+   - \`itemId\`: The \`id\` field from the consumed item you identified in step 2
+
+**Important Notes**:
+- You must first retrieve the consumed items to get the item ID
+- The \`itemId\` is different from \`product_id\` - use the \`id\` field from the consumed item
+- The date should be in ISO format (YYYY-MM-DD)
+- If multiple items match the description, you may need to ask the user to clarify which specific item to remove`
+                        }
                     }
-                },
-            ],
-        }));
-        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-            const { name, arguments: args } = request.params;
-            try {
-                switch (name) {
-                    case 'get_product':
-                        return await this.getProduct(GetProductInputSchema.parse(args));
-                    case 'get_user':
-                        return await this.getUser();
-                    case 'get_user_consumed_items':
-                        return await this.getUserConsumedItems(GetFoodEntriesInputSchema.parse(args));
-                    case 'get_user_dietary_preferences':
-                        return await this.getUserDietaryPreferences();
-                    case 'get_user_exercises':
-                        return await this.getUserExercises(GetUserExercisesInputSchema.parse(args));
-                    case 'get_user_goals':
-                        return await this.getUserGoals();
-                    case 'get_user_settings':
-                        return await this.getUserSettings();
-                    case 'get_user_suggested_products':
-                        return await this.getUserSuggestedProducts(GetUserSuggestedProductsInputSchema.parse(args));
-                    case 'get_user_water_intake':
-                        return await this.getUserWaterIntake(GetWaterIntakeInputSchema.parse(args));
-                    case 'get_user_weight':
-                        return await this.getUserWeight();
-                    case 'search_products':
-                        return await this.searchProducts(SearchProductsInputSchema.parse(args));
-                    case 'get_user_daily_summary':
-                        return await this.getUserDailySummary(GetDailySummaryInputSchema.parse(args));
-                    case 'add_user_consumed_item':
-                        return await this.addUserConsumedItem(AddConsumedItemInputSchema.parse(args));
-                    case 'remove_user_consumed_item':
-                        return await this.removeUserConsumedItem(RemoveConsumedItemInputSchema.parse(args));
-                    default:
-                        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
-                }
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                throw new McpError(ErrorCode.InternalError, errorMessage);
-            }
+                ]
+            };
         });
     }
     async ensureAuthenticated() {
@@ -330,9 +380,10 @@ class YazioMcpServer {
                 content: [
                     {
                         type: 'text',
-                        text: `Search results for "${args.query}":\n\n${JSON.stringify(products, null, 2)}`,
+                        text: `Products:\n\n${JSON.stringify(products, null, 2)}`,
                     },
                 ],
+                products,
             };
         }
         catch (error) {
@@ -418,14 +469,15 @@ class YazioMcpServer {
     async addUserConsumedItem(args) {
         const client = await this.ensureAuthenticated();
         try {
-            // The Yazio API expects specific parameters, we'll pass them directly
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const result = await client.user.addConsumedItem(args);
+            await client.user.addConsumedItem({
+                ...args,
+                id: uuidv4(),
+            });
             return {
                 content: [
                     {
                         type: 'text',
-                        text: `Successfully added consumed item:\n\n${JSON.stringify(result, null, 2)}`,
+                        text: `Successfully added consumed item`,
                     },
                 ],
             };

package/dist/schemas.d.ts

@@ -1,126 +1,93 @@
-import { z } from 'zod';
-export declare const DaytimeSchema: z.ZodEnum<["breakfast", "lunch", "dinner", "snack"]>;
-export type Daytime = z.infer<typeof DaytimeSchema>;
-export declare const DateStringSchema: z.ZodString;
-export declare const ProductIdSchema: z.ZodString;
-export declare const ItemIdSchema: z.ZodString;
+import * as z from "zod";
+export declare const DaytimeSchema: z.ZodEnum<{
+    breakfast: "breakfast";
+    lunch: "lunch";
+    dinner: "dinner";
+    snack: "snack";
+}>;
+export declare const DateStringSchema: z.ZodISODate;
+export declare const ProductIdSchema: z.ZodUUID;
+export declare const ItemIdSchema: z.ZodUUID;
+export declare const ServingTypeSchema: z.ZodString;
 export declare const QueryStringSchema: z.ZodString;
 export declare const LimitSchema: z.ZodOptional<z.ZodNumber>;
 export declare const DateInputSchema: z.ZodObject<{
-    date: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    date: string;
-}, {
-    date: string;
-}>;
+    date: z.ZodISODate;
+}, z.core.$strip>;
 export declare const OptionalDateInputSchema: z.ZodObject<{
-    date: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    date?: string | undefined;
-}, {
-    date?: string | undefined;
-}>;
+    date: z.ZodOptional<z.ZodISODate>;
+}, z.core.$strip>;
 export declare const QueryInputSchema: z.ZodObject<{
     query: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    query: string;
-}, {
-    query: string;
-}>;
+}, z.core.$strip>;
 export declare const OptionalQueryInputSchema: z.ZodObject<{
     query: z.ZodOptional<z.ZodString>;
     limit: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    query?: string | undefined;
-    limit?: number | undefined;
-}, {
-    query?: string | undefined;
-    limit?: number | undefined;
-}>;
-export declare const EmptyInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+}, z.core.$strip>;
+export declare const EmptyInputSchema: z.ZodObject<{}, z.core.$strip>;
 export declare const GetFoodEntriesInputSchema: z.ZodObject<{
-    date: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    date: string;
-}, {
-    date: string;
-}>;
+    date: z.ZodISODate;
+}, z.core.$strip>;
 export declare const GetDailySummaryInputSchema: z.ZodObject<{
-    date: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    date: string;
-}, {
-    date: string;
-}>;
-export declare const GetUserInfoInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-export declare const GetUserWeightInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    date: z.ZodISODate;
+}, z.core.$strip>;
+export declare const GetUserInfoInputSchema: z.ZodObject<{}, z.core.$strip>;
+export declare const GetUserWeightInputSchema: z.ZodObject<{}, z.core.$strip>;
 export declare const GetWaterIntakeInputSchema: z.ZodObject<{
-    date: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    date: string;
-}, {
-    date: string;
-}>;
+    date: z.ZodISODate;
+}, z.core.$strip>;
 export declare const SearchProductsInputSchema: z.ZodObject<{
     query: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    query: string;
-}, {
-    query: string;
-}>;
+}, z.core.$strip>;
+export declare const SearchProductsOutputSchema: z.ZodObject<{
+    products: z.ZodArray<z.ZodObject<{
+        score: z.ZodNumber;
+        name: z.ZodString;
+        product_id: z.ZodUUID;
+        serving: z.ZodString;
+        serving_quantity: z.ZodNumber;
+        amount: z.ZodNumber;
+        base_unit: z.ZodEnum<{
+            g: "g";
+            ml: "ml";
+        }>;
+        producer: z.ZodNullable<z.ZodString>;
+        is_verified: z.ZodBoolean;
+        nutrients: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        countries: z.ZodArray<z.ZodString>;
+        language: z.ZodString;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const GetProductInputSchema: z.ZodObject<{
-    id: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-}, {
-    id: string;
-}>;
+    id: z.ZodUUID;
+}, z.core.$strip>;
 export declare const GetUserExercisesInputSchema: z.ZodObject<{
-    date: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    date?: string | undefined;
-}, {
-    date?: string | undefined;
-}>;
-export declare const GetUserSettingsInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    date: z.ZodOptional<z.ZodISODate>;
+}, z.core.$strip>;
+export declare const GetUserSettingsInputSchema: z.ZodObject<{}, z.core.$strip>;
 export declare const GetUserSuggestedProductsInputSchema: z.ZodObject<{
     query: z.ZodOptional<z.ZodString>;
     limit: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    query?: string | undefined;
-    limit?: number | undefined;
-}, {
-    query?: string | undefined;
-    limit?: number | undefined;
-}>;
+}, z.core.$strip>;
 export declare const AddConsumedItemInputSchema: z.ZodObject<{
-    productId: z.ZodOptional<z.ZodString>;
-    amount: z.ZodOptional<z.ZodNumber>;
-    unit: z.ZodOptional<z.ZodString>;
-    date: z.ZodOptional<z.ZodString>;
-    mealType: z.ZodOptional<z.ZodEnum<["breakfast", "lunch", "dinner", "snack"]>>;
-}, "strip", z.ZodTypeAny, {
-    date?: string | undefined;
-    productId?: string | undefined;
-    amount?: number | undefined;
-    unit?: string | undefined;
-    mealType?: "breakfast" | "lunch" | "dinner" | "snack" | undefined;
-}, {
-    date?: string | undefined;
-    productId?: string | undefined;
-    amount?: number | undefined;
-    unit?: string | undefined;
-    mealType?: "breakfast" | "lunch" | "dinner" | "snack" | undefined;
-}>;
+    product_id: z.ZodUUID;
+    date: z.ZodISODate;
+    daytime: z.ZodEnum<{
+        breakfast: "breakfast";
+        lunch: "lunch";
+        dinner: "dinner";
+        snack: "snack";
+    }>;
+    amount: z.ZodNumber;
+    serving: z.ZodOptional<z.ZodString>;
+    serving_quantity: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
 export declare const RemoveConsumedItemInputSchema: z.ZodObject<{
-    itemId: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    itemId: string;
-}, {
-    itemId: string;
-}>;
-export declare const GetDietaryPreferencesInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
-export declare const GetUserGoalsInputSchema: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+    itemId: z.ZodUUID;
+}, z.core.$strip>;
+export declare const GetDietaryPreferencesInputSchema: z.ZodObject<{}, z.core.$strip>;
+export declare const GetUserGoalsInputSchema: z.ZodObject<{}, z.core.$strip>;
+export type Daytime = z.infer<typeof DaytimeSchema>;
 export type GetFoodEntriesInput = z.infer<typeof GetFoodEntriesInputSchema>;
 export type GetDailySummaryInput = z.infer<typeof GetDailySummaryInputSchema>;
 export type GetUserInfoInput = z.infer<typeof GetUserInfoInputSchema>;

package/dist/schemas.js

@@ -1,15 +1,16 @@
-import { z } from 'zod';
+import * as z from "zod";
 export const DaytimeSchema = z.enum(['breakfast', 'lunch', 'dinner', 'snack']);
-export const DateStringSchema = z.string().describe('Date in YYYY-MM-DD format');
-export const ProductIdSchema = z.string().describe('Unique product identifier');
-export const ItemIdSchema = z.string().describe('Unique item identifier');
+export const DateStringSchema = z.iso.date().describe('Date in YYYY-MM-DD format');
+export const ProductIdSchema = z.uuid().describe('Product UUID v1/v4 (e.g. 4ceff6e9-78ce-441b-964a-22e81c1dee92)');
+export const ItemIdSchema = ProductIdSchema.describe('Unique item identifier');
+export const ServingTypeSchema = z.string().describe('Serving type (e.g. portion, fruit, glass, cup, slice, piece, bar, gram, bottle, can, etc.)');
 export const QueryStringSchema = z.string().describe('Search query string');
 export const LimitSchema = z.number().optional().describe('Maximum number of results to return');
 export const DateInputSchema = z.object({
-    date: DateStringSchema.describe('Date to get data for')
+    date: DateStringSchema
 });
 export const OptionalDateInputSchema = z.object({
-    date: DateStringSchema.optional().describe('Specific date to get data for (optional)')
+    date: DateStringSchema.optional()
 });
 export const QueryInputSchema = z.object({
     query: QueryStringSchema.describe('Search query')
@@ -25,6 +26,22 @@ export const GetUserInfoInputSchema = EmptyInputSchema;
 export const GetUserWeightInputSchema = EmptyInputSchema; // Yazio getWeight doesn't accept parameters
 export const GetWaterIntakeInputSchema = DateInputSchema;
 export const SearchProductsInputSchema = QueryInputSchema;
+export const SearchProductsOutputSchema = z.object({
+    products: z.array(z.object({
+        score: z.number(),
+        name: z.string(),
+        product_id: ProductIdSchema,
+        serving: ServingTypeSchema,
+        serving_quantity: z.number(),
+        amount: z.number(),
+        base_unit: z.enum(['g', 'ml']).describe('Base unit: grams (g) or milliliters (ml)'),
+        producer: z.string().nullable().describe('Producer name'),
+        is_verified: z.boolean(),
+        nutrients: z.record(z.string(), z.number()).describe('Nutrients object with keys like energy.energy, nutrient.carb, etc.'),
+        countries: z.array(z.string()).describe('Array of country codes (e.g. ["US", "DE"])'),
+        language: z.string().describe('Language code (e.g. "en", "de")'),
+    })),
+});
 export const GetProductInputSchema = z.object({
     id: ProductIdSchema.describe('Product ID to get details for')
 });
@@ -32,11 +49,13 @@ export const GetUserExercisesInputSchema = OptionalDateInputSchema; // Only supp
 export const GetUserSettingsInputSchema = EmptyInputSchema;
 export const GetUserSuggestedProductsInputSchema = OptionalQueryInputSchema;
 export const AddConsumedItemInputSchema = z.object({
-    productId: z.string().optional().describe('ID of the product to add'),
-    amount: z.number().optional().describe('Amount of the product consumed'),
-    unit: z.string().optional().describe('Unit of measurement (g, ml, pieces, etc.)'),
-    date: z.string().optional().describe('Date when the food was consumed (defaults to today) in YYYY-MM-DD format'),
-    mealType: DaytimeSchema.optional().describe('Type of meal')
+    // id: ProductIdSchema.describe('Random identifier for the consumed item'),
+    product_id: ProductIdSchema,
+    date: DateStringSchema.describe('Date when the food was consumed'),
+    daytime: DaytimeSchema.describe('Type of meal (breakfast, lunch, dinner, snack)'),
+    amount: z.number().describe('Amount of the product consumed in base units (g or ml)'),
+    serving: ServingTypeSchema.optional(),
+    serving_quantity: z.number().optional().describe('Quantity of servings')
 });
 export const RemoveConsumedItemInputSchema = z.object({
     itemId: ItemIdSchema.describe('ID of the consumed item to remove')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yazio-mcp",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "description": "MCP server for accessing Yazio user & nutrition data (unofficial)",
   "mcpName": "io.github.fliptheweb/yazio-mcp",
   "author": "fliptheweb",
@@ -47,16 +47,15 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.18.2",
+    "@modelcontextprotocol/sdk": "^1.25.0",
+    "uuid": "^13.0.0",
     "yazio": "^1.0.0",
-    "zod": "^3.22.0",
-    "zod-to-json-schema": "^3.24.6"
+    "zod": "^4.2.1"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",
     "@typescript-eslint/eslint-plugin": "^8.44.1",
     "@typescript-eslint/parser": "^8.44.1",
-    "ajv-cli": "^5.0.0",
     "eslint": "^9.36.0",
     "globals": "^16.4.0",
     "prettier": "^3.6.2",