daiso 1.0.4 → 1.0.6

package/dist/services/seveneleven/inventory.js

@@ -0,0 +1,302 @@
+/**
+ * 세븐일레븐 재고 조회 클라이언트
+ *
+ * 상품 검색 + 매장 검색 + 재고 API를 조합하여 재고 정보를 제공합니다.
+ * 재고 API가 암호화로 차단된 경우에도 상품/매장 정보를 graceful하게 반환합니다.
+ */
+/* c8 ignore start */
+import { fetchJson, HttpError } from '../../utils/http.js';
+import { SEVENELEVEN_API } from './api.js';
+import { fetchSevenElevenStockProductMeta, fetchSevenElevenStoresByKeyword, } from './client.js';
+import { pickBestSevenElevenProduct, searchSevenElevenProductsWithVariants } from './productKeyword.js';
+const SEVENELEVEN_DEFAULT_HEADERS = {
+    Accept: 'application/json, text/plain, */*',
+    'Content-Type': 'application/json',
+    'User-Agent': 'Mozilla/5.0 (Linux; Android 15)',
+};
+function toNumber(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : 0;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number.parseFloat(value);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    return 0;
+}
+function toStringValue(value) {
+    return typeof value === 'string' ? value : '';
+}
+function normalizeStockStore(raw) {
+    return {
+        storeCode: toStringValue(raw.storeCd),
+        storeName: '',
+        address: '',
+        latitude: 0,
+        longitude: 0,
+        stockQuantity: toNumber(raw.stock),
+        isSoldOut: toNumber(raw.stock) <= 0,
+        distanceM: null,
+    };
+}
+function tryParseJsonObject(text) {
+    if (text.trim().length === 0) {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(text);
+        return typeof parsed === 'object' && parsed !== null ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function toNullableNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string' && value.trim().length > 0) {
+        const parsed = Number.parseFloat(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+}
+function normalizeEnvelopeError(response) {
+    const hasErrorFlag = response.success === false;
+    const hasErrorCode = typeof response.code === 'number' && (response.code < 200 || response.code >= 300);
+    const hasErrorMessage = typeof response.message === 'string' && response.message.trim().length > 0;
+    if (response.success === true && !hasErrorCode) {
+        return null;
+    }
+    if (!hasErrorFlag && !hasErrorCode && !hasErrorMessage) {
+        return null;
+    }
+    return {
+        cause: 'api',
+        httpStatus: null,
+        code: toNullableNumber(response.code),
+        message: typeof response.message === 'string' ? response.message : '재고 API가 오류를 반환했습니다.',
+        raw: JSON.stringify(response),
+    };
+}
+function normalizeStockError(error) {
+    if (error instanceof HttpError) {
+        const parsedBody = tryParseJsonObject(error.bodyText);
+        return {
+            cause: 'api',
+            httpStatus: error.status,
+            code: toNullableNumber(parsedBody?.code),
+            message: typeof parsedBody?.message === 'string' && parsedBody.message.trim().length > 0
+                ? parsedBody.message
+                : error.message,
+            raw: error.bodyText.trim().length > 0 ? error.bodyText : null,
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            cause: 'network',
+            httpStatus: null,
+            code: null,
+            message: error.message,
+            raw: null,
+        };
+    }
+    return {
+        cause: 'unknown',
+        httpStatus: null,
+        code: null,
+        message: '알 수 없는 재고 API 오류',
+        raw: null,
+    };
+}
+function haversineDistanceM(lat1, lon1, lat2, lon2) {
+    const R = 6371000;
+    const toRad = (deg) => (deg * Math.PI) / 180;
+    const dLat = toRad(lat2 - lat1);
+    const dLon = toRad(lon2 - lon1);
+    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLon / 2) * Math.sin(dLon / 2);
+    return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+}
+function attachDistanceToStockStores(stores, refLat, refLon) {
+    return stores.map((store) => {
+        if (store.latitude === 0 && store.longitude === 0) {
+            return store;
+        }
+        return {
+            ...store,
+            distanceM: Math.round(haversineDistanceM(refLat, refLon, store.latitude, store.longitude)),
+        };
+    });
+}
+function normalizeStoreKeyword(keyword) {
+    return keyword
+        .trim()
+        .replace(/\s+/g, '')
+        .replace(/(역|지점|점)$/g, '')
+        .toLowerCase();
+}
+function tokenizeStoreKeyword(keyword) {
+    return keyword
+        .trim()
+        .split(/\s+/)
+        .map((token) => normalizeStoreKeyword(token))
+        .filter((token) => token.length > 0);
+}
+function filterStoresByKeyword(stores, keyword) {
+    if (!keyword || keyword.trim().length === 0) {
+        return stores;
+    }
+    const normalized = normalizeStoreKeyword(keyword);
+    const exactMatched = stores.filter((store) => {
+        const nameNorm = store.storeName.replace(/\s+/g, '').toLowerCase();
+        const addrNorm = store.address.replace(/\s+/g, '').toLowerCase();
+        return nameNorm.includes(normalized) || addrNorm.includes(normalized);
+    });
+    if (exactMatched.length > 0) {
+        return exactMatched;
+    }
+    const tokens = tokenizeStoreKeyword(keyword).filter((token) => token.length >= 2);
+    if (tokens.length === 0) {
+        return stores;
+    }
+    const tokenMatched = stores.filter((store) => {
+        const combined = `${store.storeName} ${store.address}`.replace(/\s+/g, '').toLowerCase();
+        return tokens.every((token) => combined.includes(token));
+    });
+    return tokenMatched.length > 0 ? tokenMatched : stores;
+}
+async function tryStockApi(stockProduct, stores, options = {}) {
+    const { timeout = 15000 } = options;
+    const url = `${SEVENELEVEN_API.BASE_URL}${SEVENELEVEN_API.REAL_STOCK_MULTI_PATH}/01/stocks`;
+    const payload = {
+        smCd: stockProduct.smCode,
+        stokMngCd: stockProduct.stockManagementCode,
+        stokMngQty: stockProduct.stockManagementQuantity,
+        stockApplicationRate: stockProduct.stockApplicationRate,
+        storeList: stores.map((store) => store.storeCode).filter((storeCode) => storeCode.length > 0),
+    };
+    if (payload.smCd.length === 0 || payload.stokMngCd.length === 0 || payload.storeList.length === 0) {
+        return { stores: null, error: null };
+    }
+    try {
+        const response = await fetchJson(url, {
+            method: 'POST',
+            timeout,
+            headers: SEVENELEVEN_DEFAULT_HEADERS,
+            body: JSON.stringify(payload),
+        });
+        const responseError = normalizeEnvelopeError(response);
+        if (responseError) {
+            return { stores: null, error: responseError };
+        }
+        const data = response.data || {};
+        const rawStores = Array.isArray(data.storeList) ? data.storeList : [];
+        return {
+            stores: rawStores
+                .map((item) => normalizeStockStore(item))
+                .filter((store) => store.storeCode.length > 0),
+            error: null,
+        };
+    }
+    catch (error) {
+        return {
+            stores: null,
+            error: normalizeStockError(error),
+        };
+    }
+}
+export async function checkSevenElevenInventory(params, options = {}) {
+    const { productKeyword, storeKeyword, storeLimit = 20 } = params;
+    // 1) 상품 검색
+    const productResult = await searchSevenElevenProductsWithVariants(productKeyword, options);
+    const firstProduct = pickBestSevenElevenProduct(productResult.products, productKeyword) ||
+        productResult.products.find((p) => p.itemCode.length > 0) ||
+        productResult.products[0] ||
+        null;
+    // 2) 매장 검색
+    const storeResult = await fetchSevenElevenStoresByKeyword({ keyword: storeKeyword, limit: 100 }, options);
+    const matchedStores = filterStoresByKeyword(storeResult.stores, storeKeyword);
+    // 3) 재고 API 시도 (실패 시 graceful fallback)
+    let stockStores = null;
+    let stockError = null;
+    if (firstProduct && firstProduct.itemCode.length > 0) {
+        try {
+            const stockProduct = await fetchSevenElevenStockProductMeta(firstProduct.itemCode, options);
+            if (stockProduct) {
+                const stockAttempt = await tryStockApi(stockProduct, matchedStores, options);
+                stockStores = stockAttempt.stores;
+                stockError = stockAttempt.error;
+            }
+        }
+        catch (error) {
+            stockError = normalizeStockError(error);
+        }
+    }
+    // 4) 결과 조합
+    let resultStores;
+    let stockAvailable;
+    if (stockStores !== null && stockStores.length > 0) {
+        stockAvailable = true;
+        const stockMap = new Map(stockStores.map((store) => [store.storeCode, store]));
+        resultStores = matchedStores.map((store) => {
+            const stockStore = stockMap.get(store.storeCode);
+            return {
+                storeCode: store.storeCode,
+                storeName: store.storeName,
+                address: store.address,
+                latitude: store.latitude,
+                longitude: store.longitude,
+                stockQuantity: stockStore?.stockQuantity ?? -1,
+                isSoldOut: stockStore ? stockStore.isSoldOut : false,
+                distanceM: null,
+            };
+        });
+    }
+    else {
+        stockAvailable = false;
+        resultStores = matchedStores.map((store) => ({
+            storeCode: store.storeCode,
+            storeName: store.storeName,
+            address: store.address,
+            latitude: store.latitude,
+            longitude: store.longitude,
+            stockQuantity: -1,
+            isSoldOut: false,
+            distanceM: null,
+        }));
+    }
+    // 거리 계산: 첫 번째 매장 좌표를 기준으로 정렬
+    const refStore = matchedStores.find((s) => s.latitude !== 0 && s.longitude !== 0);
+    if (refStore) {
+        resultStores = attachDistanceToStockStores(resultStores, refStore.latitude, refStore.longitude);
+        resultStores.sort((a, b) => {
+            if (a.distanceM === null && b.distanceM === null)
+                return 0;
+            if (a.distanceM === null)
+                return 1;
+            if (b.distanceM === null)
+                return -1;
+            return a.distanceM - b.distanceM;
+        });
+    }
+    const limited = resultStores.slice(0, storeLimit);
+    const inStockCount = stockAvailable ? limited.filter((s) => s.stockQuantity > 0).length : 0;
+    return {
+        productKeyword,
+        product: firstProduct
+            ? {
+                itemCode: firstProduct.itemCode,
+                itemName: firstProduct.itemName,
+                salePrice: firstProduct.salePrice,
+                imageUrl: firstProduct.imageUrl,
+            }
+            : null,
+        stockAvailable,
+        stockError,
+        totalStoreCount: resultStores.length,
+        inStockStoreCount: inStockCount,
+        stores: limited,
+    };
+}
+/* c8 ignore stop */

package/dist/services/seveneleven/productKeyword.js

@@ -0,0 +1,141 @@
+/**
+ * 세븐일레븐 상품 검색어 보정
+ */
+import { searchSevenElevenProducts } from './client.js';
+const SANDWICH_SUFFIX_FAMILY = ['샌드위치', '샌드', '산도'];
+function normalizeProductText(value) {
+    return value.replace(/[^0-9A-Za-z가-힣]+/g, '').toLowerCase();
+}
+function removeSuffixFamily(value) {
+    for (const suffix of SANDWICH_SUFFIX_FAMILY) {
+        if (value.endsWith(suffix)) {
+            return value.slice(0, -suffix.length);
+        }
+    }
+    return value;
+}
+/**
+ * 세븐일레븐 상품 검색용 보정 질의를 생성합니다.
+ */
+export function buildSevenElevenProductKeywordVariants(rawKeyword) {
+    const base = rawKeyword.trim();
+    if (!base) {
+        return [];
+    }
+    const compact = base.replace(/\s+/g, '');
+    const stem = removeSuffixFamily(compact);
+    const candidates = [base, compact];
+    if (stem && stem !== compact) {
+        candidates.push(stem);
+        for (const suffix of SANDWICH_SUFFIX_FAMILY) {
+            candidates.push(`${stem}${suffix}`);
+        }
+        candidates.push('샌드');
+    }
+    return [...new Set(candidates.map((value) => value.trim()).filter((value) => value.length > 0))];
+}
+/**
+ * 원본 검색어 기준으로 가장 그럴듯한 상품을 고릅니다.
+ */
+export function pickBestSevenElevenProduct(products, rawKeyword) {
+    let bestProduct = null;
+    let bestScore = -1;
+    for (const product of products) {
+        const score = scoreSevenElevenProduct(product, rawKeyword);
+        if (score > bestScore) {
+            bestScore = score;
+            bestProduct = product;
+        }
+    }
+    return bestScore > 0 ? bestProduct : null;
+}
+function scoreSevenElevenProduct(product, rawKeyword) {
+    const original = normalizeProductText(rawKeyword);
+    const stem = normalizeProductText(removeSuffixFamily(rawKeyword.replace(/\s+/g, '')));
+    const variants = buildSevenElevenProductKeywordVariants(rawKeyword)
+        .map(normalizeProductText)
+        .filter((value) => value.length > 0);
+    const hasSandwichSuffix = stem.length > 0 && stem !== original;
+    const normalizedName = normalizeProductText(product.itemName);
+    if (normalizedName.length === 0) {
+        return -1;
+    }
+    let score = 0;
+    if (original.length > 0 && normalizedName === original) {
+        score += 200;
+    }
+    if (original.length > 0 && normalizedName.includes(original)) {
+        score += 120;
+    }
+    if (stem.length > 0 && stem !== original && normalizedName.includes(stem)) {
+        score += 45;
+    }
+    for (const variant of variants) {
+        if (variant.length < 2 || variant === original || variant === stem) {
+            continue;
+        }
+        if (normalizedName.includes(variant)) {
+            score += 15;
+        }
+    }
+    if (hasSandwichSuffix && SANDWICH_SUFFIX_FAMILY.some((suffix) => normalizedName.includes(suffix))) {
+        score += 35;
+    }
+    if (hasSandwichSuffix &&
+        stem.length > 0 &&
+        SANDWICH_SUFFIX_FAMILY.some((suffix) => normalizedName.includes(`${stem}${suffix}`))) {
+        score += 50;
+    }
+    if (product.itemCode.length > 0) {
+        score += 1;
+    }
+    return score;
+}
+/**
+ * 보정 질의를 순차 적용해 세븐일레븐 상품을 찾습니다.
+ */
+export async function searchSevenElevenProductsWithVariants(query, options = {}) {
+    const { page = 1, size = 20, sort = 'recommend', timeout } = options;
+    const appliedQueries = buildSevenElevenProductKeywordVariants(query);
+    const seenKeys = new Set();
+    const collectionIds = new Set();
+    const mergedProducts = [];
+    for (const candidate of appliedQueries) {
+        const result = await searchSevenElevenProducts({
+            query: candidate,
+            page,
+            size,
+            sort,
+        }, {
+            timeout,
+        });
+        for (const collectionId of result.collectionIds) {
+            collectionIds.add(collectionId);
+        }
+        for (const product of result.products) {
+            const key = product.itemCode || product.productNo || product.itemName;
+            if (!key || seenKeys.has(key)) {
+                continue;
+            }
+            seenKeys.add(key);
+            mergedProducts.push(product);
+        }
+    }
+    const rankedProducts = [...mergedProducts].sort((left, right) => {
+        const leftScore = scoreSevenElevenProduct(left, query);
+        const rightScore = scoreSevenElevenProduct(right, query);
+        if (leftScore !== rightScore) {
+            return rightScore - leftScore;
+        }
+        return 0;
+    });
+    const start = Math.max(page - 1, 0) * size;
+    const pagedProducts = rankedProducts.slice(start, start + size);
+    return {
+        query,
+        totalCount: rankedProducts.length,
+        products: pagedProducts,
+        collectionIds: [...collectionIds],
+        appliedQueries,
+    };
+}

package/dist/services/seveneleven/tools/checkInventory.js

@@ -0,0 +1,82 @@
+/**
+ * 세븐일레븐 재고 확인 도구
+ *
+ * 상품 검색 + 매장 검색을 결합하여 특정 지역 매장의 재고를 조회합니다.
+ * 재고 API가 암호화로 차단된 경우에도 상품/매장 정보를 함께 제공합니다.
+ */
+/* c8 ignore start */
+import * as z from 'zod';
+import { checkSevenElevenInventory } from '../inventory.js';
+function isEncryptedStockFailure(stockError) {
+    if (!stockError) {
+        return false;
+    }
+    const codeMatched = stockError.code === 501 || stockError.code === 503;
+    const messageSource = `${stockError.message} ${stockError.raw ?? ''}`;
+    const messageMatched = /RSA|복호화|암호화|서비스를 사용할 수 없습니다/i.test(messageSource);
+    return codeMatched || messageMatched;
+}
+async function checkInventory(args) {
+    const { keyword, storeKeyword = '', storeLimit = 20, timeoutMs = 20000, } = args;
+    if (!keyword || keyword.trim().length === 0) {
+        throw new Error('상품 검색어(keyword)를 입력해주세요.');
+    }
+    const result = await checkSevenElevenInventory({
+        productKeyword: keyword,
+        storeKeyword,
+        storeLimit,
+    }, {
+        timeout: timeoutMs,
+    });
+    const note = !result.product
+        ? '상품 검색 결과가 없어 재고를 조회하지 못했습니다. 다른 상품명이나 더 짧은 키워드로 다시 시도해주세요.'
+        : result.stockAvailable
+            ? '실시간 재고 데이터가 포함되어 있습니다.'
+            : isEncryptedStockFailure(result.stockError)
+                ? '실시간 재고 API가 암호화 검증에서 거절되었습니다. 현재 구현의 평문 요청만으로는 재고 수량을 조회할 수 없습니다.'
+                : result.stockError
+                    ? `실시간 재고 API 호출에 실패했습니다: ${result.stockError.message}`
+                    : '실시간 재고 API가 현재 제한되어 있어 매장 목록만 제공됩니다. stockQuantity가 -1인 경우 재고 수량 미확인 상태입니다.';
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    keyword,
+                    storeKeyword,
+                    product: result.product,
+                    stockAvailable: result.stockAvailable,
+                    stockError: result.stockError,
+                    note,
+                    inventory: {
+                        totalStoreCount: result.totalStoreCount,
+                        inStockStoreCount: result.inStockStoreCount,
+                        count: result.stores.length,
+                        stores: result.stores,
+                    },
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createCheckInventoryTool() {
+    return {
+        name: 'seveneleven_check_inventory',
+        metadata: {
+            title: '세븐일레븐 재고 확인',
+            description: '상품 키워드와 매장/지역 키워드로 세븐일레븐 매장별 재고를 조회합니다. 실시간 재고 API가 제한된 경우에도 상품 정보와 근처 매장 목록을 함께 제공합니다.',
+            inputSchema: {
+                keyword: z.string().describe('상품 검색어 (예: 핫식스, 삼각김밥, 도시락)'),
+                storeKeyword: z
+                    .string()
+                    .optional()
+                    .default('')
+                    .describe('매장/지역 검색 키워드 (예: 안산 중앙역, 강남역, 홍대)'),
+                storeLimit: z.number().optional().default(20).describe('반환할 최대 매장 수 (기본값: 20)'),
+                timeoutMs: z.number().optional().default(20000).describe('요청 제한 시간(ms, 기본값: 20000)'),
+            },
+        },
+        handler: checkInventory,
+    };
+}
+/* c8 ignore stop */

package/dist/services/seveneleven/tools/getCatalogSnapshot.js

@@ -0,0 +1,55 @@
+/**
+ * 세븐일레븐 카탈로그 스냅샷 도구
+ */
+import * as z from 'zod';
+import { fetchSevenElevenCatalogSnapshot } from '../client.js';
+async function getCatalogSnapshot(args) {
+    const { includeIssues = true, includeExhibition = true, limit = 20, timeoutMs = 15000 } = args;
+    const result = await fetchSevenElevenCatalogSnapshot({
+        includeIssues,
+        includeExhibition,
+        timeout: timeoutMs,
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    options: {
+                        includeIssues,
+                        includeExhibition,
+                        limit,
+                    },
+                    pages: {
+                        totalCount: result.pages.length,
+                        items: result.pages.slice(0, limit),
+                    },
+                    issues: {
+                        totalCount: result.issues.length,
+                        items: result.issues.slice(0, limit),
+                    },
+                    exhibitions: {
+                        totalCount: result.exhibitions.length,
+                        items: result.exhibitions.slice(0, limit),
+                    },
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createGetCatalogSnapshotTool() {
+    return {
+        name: 'seveneleven_get_catalog_snapshot',
+        metadata: {
+            title: '세븐일레븐 카탈로그 스냅샷',
+            description: '세븐일레븐 공개 카탈로그(페이지/이슈/기획전) 데이터를 조회합니다.',
+            inputSchema: {
+                includeIssues: z.boolean().optional().default(true).describe('이슈 상품 포함 여부 (기본값: true)'),
+                includeExhibition: z.boolean().optional().default(true).describe('기획전 포함 여부 (기본값: true)'),
+                limit: z.number().optional().default(20).describe('각 목록 최대 반환 수 (기본값: 20)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: getCatalogSnapshot,
+    };
+}

package/dist/services/seveneleven/tools/getSearchPopwords.js

@@ -0,0 +1,41 @@
+/**
+ * 세븐일레븐 인기 검색어 조회 도구
+ */
+import * as z from 'zod';
+import { fetchSevenElevenSearchPopwords } from '../client.js';
+async function getSearchPopwords(args) {
+    const { label = 'home', timeoutMs = 15000 } = args;
+    const keywords = await fetchSevenElevenSearchPopwords(label, {
+        timeout: timeoutMs,
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify({
+                    label,
+                    available: keywords.length > 0,
+                    count: keywords.length,
+                    keywords,
+                    note: keywords.length === 0
+                        ? '현재 응답에서 인기 검색어 목록을 찾지 못했습니다.'
+                        : '홈 인기 검색어를 조회했습니다.',
+                }, null, 2),
+            },
+        ],
+    };
+}
+export function createGetSearchPopwordsTool() {
+    return {
+        name: 'seveneleven_get_search_popwords',
+        metadata: {
+            title: '세븐일레븐 인기 검색어 조회',
+            description: '세븐일레븐 인기 검색어 목록을 조회합니다.',
+            inputSchema: {
+                label: z.string().optional().default('home').describe('조회 라벨 (기본값: home)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: getSearchPopwords,
+    };
+}

package/dist/services/seveneleven/tools/searchProducts.js

@@ -0,0 +1,67 @@
+/**
+ * 세븐일레븐 상품 검색 도구
+ */
+import * as z from 'zod';
+import { searchSevenElevenProductsWithVariants } from '../productKeyword.js';
+function buildTextResponse(payload) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+        structuredContent: payload,
+    };
+}
+async function searchProducts(args) {
+    const { query, page = 1, size = 20, sort = 'recommend', timeoutMs = 15000 } = args;
+    if (!query || query.trim().length === 0) {
+        throw new Error('상품 검색어(query)를 입력해주세요.');
+    }
+    const result = await searchSevenElevenProductsWithVariants(query, {
+        page,
+        size,
+        sort,
+        timeout: timeoutMs,
+    });
+    return buildTextResponse({
+        query: result.query,
+        page,
+        size,
+        sort,
+        totalCount: result.totalCount,
+        count: result.products.length,
+        collectionIds: result.collectionIds,
+        appliedQueries: result.appliedQueries,
+        products: result.products,
+    });
+}
+const searchProductsOutputSchema = {
+    query: z.string().describe('적용된 검색어'),
+    page: z.number().describe('페이지 번호'),
+    size: z.number().describe('페이지 크기'),
+    sort: z.string().describe('정렬 기준'),
+    totalCount: z.number().describe('검색된 전체 상품 수'),
+    count: z.number().describe('반환된 상품 수'),
+    collectionIds: z.array(z.string()).describe('검색 컬렉션 ID 목록'),
+    appliedQueries: z.array(z.string()).describe('실제로 시도한 검색어 목록'),
+    products: z.array(z.unknown()).describe('세븐일레븐 상품 검색 결과'),
+};
+export function createSearchProductsTool() {
+    return {
+        name: 'seveneleven_search_products',
+        metadata: {
+            title: '세븐일레븐 상품 검색',
+            description: '키워드로 세븐일레븐 상품을 검색합니다.',
+            inputSchema: {
+                query: z.string().describe('검색어 (예: 삼각김밥, 콜라, 도시락)'),
+                page: z.number().optional().default(1).describe('페이지 번호 (기본값: 1)'),
+                size: z.number().optional().default(20).describe('페이지당 결과 수 (기본값: 20)'),
+                sort: z
+                    .enum(['recommend', 'recent', 'popular'])
+                    .optional()
+                    .default('recommend')
+                    .describe('정렬 기준 (기본값: recommend)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+            outputSchema: searchProductsOutputSchema,
+        },
+        handler: searchProducts,
+    };
+}