byclaw-mcp 0.4.5 → 0.4.7

package/dist/index.js

@@ -132,22 +132,116 @@ server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => ({
             description: 'Get platform statistics: products compared, reviews written, recommendations sent.',
             inputSchema: { type: 'object', properties: {} },
         },
+        // ── QA / Testing ──
+        {
+            name: 'test_web_search',
+            description: 'Test the web agent search endpoint (same as dashboard search). Use for QA to verify web search behavior vs MCP shop behavior.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'Search query' },
+                    max_price: { type: 'number', description: 'Maximum price in EUR (optional)' },
+                    brand: { type: 'string', description: 'Brand filter (optional)' },
+                    language: { type: 'string', description: 'Language: de, en (optional)' },
+                },
+                required: ['query'],
+            },
+        },
     ],
 }));
 // ═══════════════════════════════════════
 //  TOOL HANDLERS
 // ═══════════════════════════════════════
 let reviewLeftThisSession = false;
+// ═══ Session state for follow-up queries ═══
+// originalQuery = the first real product search (category anchor, never overwritten by modifiers)
+// query = the effective query sent last (may be a reconstructed follow-up)
+let lastShopContext = null;
+// Patterns that indicate a follow-up to the previous search (no standalone product intent)
+const FOLLOWUP_PATTERNS = [
+    // DE
+    /^(hast du |gibt es |gibt's |zeig mir |zeig |noch |was anderes|was billigeres|was teureres)/i,
+    /^(günstiger|teurer|billiger|andere|alternative|statt dessen|weiteres|mehr davon)/i,
+    /^(das erste|den ersten|die erste|das zweite|das letzte|das nehme ich|das nehm ich)/i,
+    /^(in größe|in farbe|in schwarz|in weiß|in blau|in rot|in grün)/i,
+    /^(nochmal|nochmals|lieber|besser|schlechter|kleiner|größer)/i,
+    // EN
+    /^(show me|anything else|something else|something cheaper|something better)/i,
+    /^(instead|cheaper|more expensive|different|other options|alternatives)/i,
+    /^(the first|the second|the last|i'll take|in size|in color|in black|in white)/i,
+    /^(do you have|is there|can you|what about|how about|any other)/i,
+    // Short contextual (only match if very short — <30 chars)
+];
+// Patterns that should go to the clarification flow, NOT follow-up reconstruction
+const CLARIFICATION_PATTERNS = [
+    /^(hi|hallo|hey|hello|moin|servus|grüß)/i,
+    /^(hilf|help|ich weiß nicht|i don't know|bin unsicher|not sure)/i,
+    /^(erzähl|tell me more|was meinst|what do you mean|ich verstehe)/i,
+    /^(was |irgendwas|irgendwelche|something|anything)$/i,
+    /^(danke|thanks|ok|okay|ja|nein|yes|no)$/i,
+];
+function isFollowUp(q) {
+    if (!lastShopContext)
+        return false;
+    const trimmed = q.trim();
+    // Clarification queries should NOT be reconstructed as follow-ups
+    if (CLARIFICATION_PATTERNS.some(p => p.test(trimmed)))
+        return false;
+    // Very short queries (<30 chars) without a product noun are likely follow-ups
+    if (trimmed.length < 30 && !/\b(kopfhörer|headphones|schuhe|shoes|tasche|bag|uhr|watch|laptop|phone|tablet|kamera|camera|rucksack|jacke|jacket)\b/i.test(trimmed)) {
+        if (FOLLOWUP_PATTERNS.some(p => p.test(trimmed)))
+            return true;
+    }
+    // Longer queries: only match if they start with a clear follow-up pattern
+    if (trimmed.length <= 80 && FOLLOWUP_PATTERNS.some(p => p.test(trimmed)))
+        return true;
+    return false;
+}
+function buildFollowUpQuery(q) {
+    if (!lastShopContext)
+        return q;
+    const trimmed = q.trim().toLowerCase();
+    // "das erste nehmen" / "the first one" → return the picked product directly
+    if (/das erste|den ersten|die erste|the first|i'll take|das nehm/i.test(trimmed)) {
+        return lastShopContext.picked;
+    }
+    // "in Größe 42" / "in size 42" → can't fulfill (no size data), let API handle
+    if (/in größe|in size|in farbe|in color/i.test(trimmed)) {
+        return `${lastShopContext.picked} ${q}`;
+    }
+    // Price modifiers → use ORIGINAL category anchor + price constraint
+    const anchor = lastShopContext.originalQuery;
+    if (/günstiger|billiger|cheaper|was billigeres|noch günstiger/i.test(trimmed)) {
+        return `${anchor} unter ${Math.floor(lastShopContext.price * 0.8)}€`;
+    }
+    if (/teurer|more expensive|was teureres/i.test(trimmed)) {
+        return `${anchor} über ${Math.ceil(lastShopContext.price * 1.3)}€`;
+    }
+    // Generic "something else" / "andere" → use ORIGINAL category anchor
+    return `${anchor} — ${q}`;
+}
 server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
         switch (name) {
             case 'shop': {
+                // Follow-up detection: reconstruct query with context from last search
+                let effectiveQuery = String(args?.query || '');
+                const wasFollowUp = isFollowUp(effectiveQuery);
+                if (wasFollowUp) {
+                    effectiveQuery = buildFollowUpQuery(effectiveQuery);
+                    console.error(`[mcp] Follow-up detected: "${args?.query}" → "${effectiveQuery}"`);
+                }
                 const result = await apiCall('/api/mcp/shop', {
                     method: 'POST',
                     body: JSON.stringify({
-                        query: args?.query,
+                        query: effectiveQuery,
                         max_price: args?.max_price,
+                        previous_context: lastShopContext ? {
+                            original_query: lastShopContext.originalQuery,
+                            picked: lastShopContext.picked,
+                            price: lastShopContext.price,
+                        } : undefined,
                         category: args?.category,
                         brand: args?.brand,
                         language: args?.language,
@@ -162,16 +256,45 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                     // ── GIFT MODE ──
                     if (d.status === 'gift_found' && Array.isArray(d.gift_picks) && d.gift_picks.length > 0) {
                         const intent = d.gift_intent || {};
+                        // Track session for follow-ups (keep originalQuery stable across chains)
+                        lastShopContext = {
+                            originalQuery: wasFollowUp ? (lastShopContext?.originalQuery || String(args?.query || '')) : String(args?.query || ''),
+                            query: effectiveQuery,
+                            picked: d.gift_picks[0]?.title || '',
+                            price: d.gift_picks[0]?.price || 0,
+                            alternatives: d.gift_picks.slice(1).map((p) => p.title),
+                        };
                         return { content: [{ type: 'text', text: JSON.stringify({
-                                        type: 'gift_recommendation',
-                                        recipient: intent.summary || '',
-                                        picks: d.gift_picks.map((p) => ({
+                                        type: 'gift_found',
+                                        advisor: advisorLabel,
+                                        advisor_profile: d.advisor_profile || null,
+                                        gift_picks: d.gift_picks.map((p) => ({
                                             title: p.title,
                                             price: p.price,
+                                            brand: p.brand || '',
                                             merchant: p.merchant || '',
                                             reasoning: p.reasoning || '',
                                             url: p.affiliate_url || '',
                                         })),
+                                        gift_intent: {
+                                            recipient: intent.recipient || '',
+                                            summary: intent.summary || '',
+                                        },
+                                        affiliate_notice: disclosure,
+                                        ...(d.note ? { note: d.note } : {}),
+                                    }, null, 2) }] };
+                    }
+                    // ── CLARIFICATION MODE ──
+                    if (d.status === 'clarification_needed') {
+                        return { content: [{ type: 'text', text: JSON.stringify({
+                                        type: 'clarification_needed',
+                                        advisor: advisorLabel,
+                                        advisor_profile: d.advisor_profile || null,
+                                        message: d.message || '',
+                                        suggested_next: d.suggested_next || [],
+                                        context_summary: d.context_summary || null,
+                                        affiliate_notice: disclosure,
+                                        ...(d.note ? { note: d.note } : {}),
                                     }, null, 2) }] };
                     }
                     // ── NORMAL / FOLLOW-UP MODE ──
@@ -188,7 +311,7 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         content.push({ type: 'image', data: allImages[0].data, mimeType: allImages[0].mimeType });
                     }
                     // Add structured data — handle no_match vs product_recommendation
-                    if (d.type === 'no_match') {
+                    if (d.status === 'no_match') {
                         content.push({ type: 'text', text: JSON.stringify({
                                 type: 'no_match',
                                 advisor: advisorLabel,
@@ -232,6 +355,16 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                         if (img)
                             content.push({ type: 'image', data: img.data, mimeType: img.mimeType });
                     });
+                    // Track session for follow-ups (only on product_found, not no_match)
+                    if (d.status !== 'no_match' && d.picked) {
+                        lastShopContext = {
+                            originalQuery: wasFollowUp ? (lastShopContext?.originalQuery || String(args?.query || '')) : String(args?.query || ''),
+                            query: effectiveQuery,
+                            picked: d.picked.title || '',
+                            price: d.picked.price || 0,
+                            alternatives: (d.alternatives || []).map((a) => a.title),
+                        };
+                    }
                     return { content };
                 }
                 return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
@@ -293,6 +426,66 @@ server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
                 const result = await apiCall('/api/stats');
                 return { content: [{ type: 'text', text: JSON.stringify(result, null, 2) }] };
             }
+            case 'test_web_search': {
+                const result = await apiCall('/api/agents/shop', {
+                    method: 'POST',
+                    body: JSON.stringify({
+                        query: args?.query,
+                        max_price: args?.max_price,
+                        brand: args?.brand,
+                        language: args?.language,
+                        source: 'test',
+                    }),
+                });
+                if (!result?.ok) {
+                    return { content: [{ type: 'text', text: JSON.stringify({ type: 'web_search_error', error: result?.error || 'Unknown error', raw: result }, null, 2) }] };
+                }
+                const d = result.data;
+                // Clarification responses have different fields than product responses
+                if (d.status === 'clarification_needed') {
+                    return { content: [{ type: 'text', text: JSON.stringify({
+                                    type: 'clarification_needed',
+                                    endpoint: '/api/agents/shop',
+                                    advisor: d.advisor_profile?.name || d.agent?.personality || null,
+                                    advisor_profile: d.advisor_profile || null,
+                                    message: d.message || null,
+                                    message_de: d.message_de || null,
+                                    message_en: d.message_en || null,
+                                    suggested_next: d.suggested_next || [],
+                                    context_summary: d.context_summary || null,
+                                    disclosure: d.disclosure || null,
+                                    note: d.note || null,
+                                }, null, 2) }] };
+                }
+                // Gift responses
+                if (d.status === 'gift_found' && d.gift_picks) {
+                    return { content: [{ type: 'text', text: JSON.stringify({
+                                    type: 'gift_found',
+                                    endpoint: '/api/agents/shop',
+                                    advisor: d.advisor_profile?.name || d.agent?.personality || null,
+                                    advisor_profile: d.advisor_profile || null,
+                                    message: d.message || null,
+                                    gift_picks: d.gift_picks.map((g) => ({ title: g.title, price: g.price, brand: g.brand, reasoning: g.reasoning || null })),
+                                    gift_intent: d.gift_intent || null,
+                                    disclosure: d.disclosure || null,
+                                    note: d.note || null,
+                                }, null, 2) }] };
+                }
+                return { content: [{ type: 'text', text: JSON.stringify({
+                                type: d.status || 'web_search_result',
+                                endpoint: '/api/agents/shop',
+                                advisor: d.advisor_profile?.name || d.agent?.personality || null,
+                                advisor_profile: d.advisor_profile || null,
+                                message: d.message || null,
+                                picked: d.picked ? { title: d.picked.title, price: d.picked.price, brand: d.picked.brand, affiliate_url: d.picked.affiliate_url } : null,
+                                alternatives: (d.alternatives || []).map((a) => ({ title: a.title, price: a.price, brand: a.brand })),
+                                compared: d.compared || 0,
+                                review: d.review || d.message || null,
+                                reasoning: d.reasoning || d.message || null,
+                                disclosure: d.disclosure || null,
+                                note: d.note || null,
+                            }, null, 2) }] };
+            }
             default:
                 return { content: [{ type: 'text', text: `Unknown tool: ${name}` }], isError: true };
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "byclaw-mcp",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "MCP Server for byclaw.io — Your AI shopping advisor. Connects Claude Desktop and other MCP clients to the byclaw.io product catalog.",
   "main": "dist/index.js",
   "bin": {
@@ -11,7 +11,13 @@
     "dev": "tsx src/index.ts",
     "prepublishOnly": "npm run build"
   },
-  "keywords": ["mcp", "model-context-protocol", "ai-shopping", "claude", "byclaw"],
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "ai-shopping",
+    "claude",
+    "byclaw"
+  ],
   "author": "NJUDEV S.L.",
   "license": "MIT",
   "repository": {