daiso 1.0.6 → 1.0.8

package/dist/services/gs25/tools/findNearbyStores.js

@@ -4,8 +4,12 @@
 import * as z from 'zod';
 import { attachDistanceToGs25Stores, fetchGs25Stores, geocodeGs25Address, selectGs25StoresForKeyword, sortGs25Stores, } from '../client.js';
 const FALLBACK_STORE_LOOKUP_ITEM_CODE = '8801117752804';
+function getProcessEnvValue(name) {
+    /* c8 ignore next -- Node 테스트와 CLI 런타임은 process를 제공하며, Worker에는 API에서 키를 주입합니다. */
+    return typeof process !== 'undefined' ? process.env[name] : undefined;
+}
 async function findNearbyStores(args) {
-    const { latitude, longitude, keyword = '', serviceCode = '01', limit = 20, timeoutMs = 20000, } = args;
+    const { latitude, longitude, keyword = '', serviceCode = '01', limit = 20, timeoutMs = 20000, googleMapsApiKey = getProcessEnvValue('GOOGLE_MAPS_API_KEY'), zyteApiKey = getProcessEnvValue('ZYTE_API_KEY'), } = args;
     let resolvedLatitude = latitude;
     let resolvedLongitude = longitude;
     let geocodeUsed = false;
@@ -13,7 +17,7 @@ async function findNearbyStores(args) {
         keyword.trim().length > 0) {
         const geocoded = await geocodeGs25Address(keyword, {
             timeout: timeoutMs,
-            googleMapsApiKey: process.env.GOOGLE_MAPS_API_KEY,
+            googleMapsApiKey,
         });
         if (geocoded) {
             resolvedLatitude = geocoded.latitude;
@@ -27,6 +31,7 @@ async function findNearbyStores(args) {
         longitude: resolvedLongitude,
     }, {
         timeout: timeoutMs,
+        zyteApiKey,
     });
     let fallbackUsed = false;
     if (result.stores.length === 0 &&
@@ -42,6 +47,7 @@ async function findNearbyStores(args) {
                 useCache: false,
             }, {
                 timeout: timeoutMs,
+                zyteApiKey,
             });
             if (fallbackResult.stores.length > 0) {
                 result = fallbackResult;
@@ -83,7 +89,7 @@ async function findNearbyStores(args) {
         ],
     };
 }
-export function createFindNearbyStoresTool() {
+export function createFindNearbyStoresTool(googleMapsApiKey, zyteApiKey) {
     return {
         name: 'gs25_find_nearby_stores',
         metadata: {
@@ -95,9 +101,17 @@ export function createFindNearbyStoresTool() {
                 keyword: z.string().optional().describe('매장명/주소 키워드 (예: 강남, 안산 중앙역)'),
                 serviceCode: z.string().optional().default('01').describe('서비스 코드 (기본값: 01=GS25)'),
                 limit: z.number().optional().default(20).describe('반환할 최대 매장 수 (기본값: 20)'),
-                timeoutMs: z.number().optional().default(20000).describe('요청 제한 시간(ms, 기본값: 20000)'),
+                timeoutMs: z
+                    .number()
+                    .optional()
+                    .default(20000)
+                    .describe('요청 제한 시간(ms, 기본값: 20000)'),
             },
         },
-        handler: findNearbyStores,
+        handler: ((args) => findNearbyStores({
+            ...args,
+            googleMapsApiKey: args.googleMapsApiKey || googleMapsApiKey,
+            zyteApiKey: args.zyteApiKey || zyteApiKey,
+        })),
     };
 }

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

@@ -3,6 +3,13 @@
  */
 import * as z from 'zod';
 import { fetchGs25SearchProducts } from '../client.js';
+function getProcessEnvValue(name) {
+    if (typeof process !== 'undefined') {
+        return process.env[name];
+    }
+    /* c8 ignore next -- process가 없는 런타임 방어 분기 */
+    return undefined;
+}
 function buildTextResponse(payload) {
     return {
         content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
@@ -10,11 +17,11 @@ function buildTextResponse(payload) {
     };
 }
 async function searchProducts(args) {
-    const { keyword, limit = 20, timeoutMs = 20000 } = args;
+    const { keyword, limit = 20, timeoutMs = 20000, zyteApiKey = getProcessEnvValue('ZYTE_API_KEY'), } = args;
     if (!keyword || keyword.trim().length === 0) {
         throw new Error('상품 검색어(keyword)를 입력해주세요.');
     }
-    const products = await fetchGs25SearchProducts(keyword, { timeout: timeoutMs });
+    const products = await fetchGs25SearchProducts(keyword, { timeout: timeoutMs, zyteApiKey });
     const limitedProducts = products.slice(0, limit);
     const payload = {
         keyword,
@@ -39,7 +46,7 @@ const searchProductsOutputSchema = {
     products: z.array(z.unknown()).describe('GS25 상품 검색 결과'),
     note: z.string().describe('후속 재고 조회 안내'),
 };
-export function createSearchProductsTool() {
+export function createSearchProductsTool(zyteApiKey) {
     return {
         name: 'gs25_search_products',
         metadata: {
@@ -52,6 +59,6 @@ export function createSearchProductsTool() {
             },
             outputSchema: searchProductsOutputSchema,
         },
-        handler: searchProducts,
+        handler: ((args) => searchProducts({ ...args, zyteApiKey: zyteApiKey ?? args.zyteApiKey })),
     };
 }

package/dist/services/oliveyoung/client.js

@@ -10,6 +10,8 @@ const OLIVEYOUNG_PRODUCT_ID_CACHE_TTL_MS = 10 * 60 * 1000;
 const OLIVEYOUNG_PRODUCT_SEARCH_STALE_CACHE_TTL_MS = 30 * 60 * 1000;
 const oliveyoungProductIdCache = new Map();
 const oliveyoungProductSearchCache = new Map();
+const oliveyoungStoreSearchCache = new Map();
+const oliveyoungStockStoresCache = new Map();
 const OLIVEYOUNG_IMAGE_PATH_PREFIX = '/uploads/images/goods';
 function resolveOliveyoungInStock(o2oStockFlag, o2oRemainQuantity) {
     return o2oStockFlag || o2oRemainQuantity > 0;
@@ -67,6 +69,12 @@ function resolveOliveyoungStoreStock(rawStore) {
 function createOliveyoungProductSearchCacheKey(params) {
     return JSON.stringify([params.keyword, params.page, params.size, params.sort, params.includeSoldOut]);
 }
+function createOliveyoungStoreSearchCacheKey(params) {
+    return JSON.stringify([params.latitude, params.longitude, params.pageIdx, params.searchWords]);
+}
+function createOliveyoungStockStoresCacheKey(params) {
+    return JSON.stringify([params.productId, params.latitude, params.longitude, params.pageIdx, params.searchWords]);
+}
 function cloneOliveyoungProductSearchResult(result) {
     return {
         totalCount: result.totalCount,
@@ -74,17 +82,32 @@ function cloneOliveyoungProductSearchResult(result) {
         products: result.products.map((product) => ({ ...product })),
     };
 }
-function readStaleOliveyoungProductSearchResult(cacheKey) {
-    const cached = oliveyoungProductSearchCache.get(cacheKey);
+function cloneOliveyoungStoreSearchResult(result) {
+    return {
+        totalCount: result.totalCount,
+        stores: result.stores.map((store) => ({ ...store })),
+    };
+}
+function cloneOliveyoungStockStoresResult(result) {
+    return {
+        totalCount: result.totalCount,
+        inStockCount: result.inStockCount,
+        outOfStockCount: result.outOfStockCount,
+        notSoldCount: result.notSoldCount,
+        stores: result.stores.map((store) => ({ ...store })),
+    };
+}
+function readStaleResult(cache, cacheKey, cloneResult) {
+    const cached = cache.get(cacheKey);
     if (!cached || cached.expiresAt <= Date.now()) {
         return null;
     }
-    return cloneOliveyoungProductSearchResult(cached.result);
+    return cloneResult(cached.result);
 }
-function writeStaleOliveyoungProductSearchResult(cacheKey, result) {
-    oliveyoungProductSearchCache.set(cacheKey, {
+function writeStaleResult(cache, cacheKey, result, cloneResult) {
+    cache.set(cacheKey, {
         expiresAt: Date.now() + OLIVEYOUNG_PRODUCT_SEARCH_STALE_CACHE_TTL_MS,
-        result: cloneOliveyoungProductSearchResult(result),
+        result: cloneResult(result),
     });
 }
 async function zyteExtract(targetPath, requestBody, options = {}) {
@@ -130,20 +153,32 @@ export async function fetchOliveyoungStores(params, options = {}) {
         mapLat: params.latitude,
         mapLon: params.longitude,
     };
-    const body = await zyteExtract(OLIVEYOUNG_API.STORE_FINDER_PATH, payload, options);
-    const stores = (body.data?.storeList || []).map((store) => ({
-        storeCode: store.storeCode || '',
-        storeName: store.storeName || '',
-        address: store.address || '',
-        latitude: store.latitude || 0,
-        longitude: store.longitude || 0,
-        pickupYn: Boolean(store.pickupYn),
-        o2oRemainQuantity: store.o2oRemainQuantity || 0,
-    }));
-    return {
-        totalCount: body.data?.totalCount || 0,
-        stores,
-    };
+    const cacheKey = createOliveyoungStoreSearchCacheKey(params);
+    try {
+        const body = await zyteExtract(OLIVEYOUNG_API.STORE_FINDER_PATH, payload, options);
+        const stores = (body.data?.storeList || []).map((store) => ({
+            storeCode: store.storeCode || '',
+            storeName: store.storeName || '',
+            address: store.address || '',
+            latitude: store.latitude || 0,
+            longitude: store.longitude || 0,
+            pickupYn: Boolean(store.pickupYn),
+            o2oRemainQuantity: store.o2oRemainQuantity || 0,
+        }));
+        const result = {
+            totalCount: body.data?.totalCount || 0,
+            stores,
+        };
+        writeStaleResult(oliveyoungStoreSearchCache, cacheKey, result, cloneOliveyoungStoreSearchResult);
+        return result;
+    }
+    catch (error) {
+        const staleResult = readStaleResult(oliveyoungStoreSearchCache, cacheKey, cloneOliveyoungStoreSearchResult);
+        if (staleResult) {
+            return staleResult;
+        }
+        throw error;
+    }
 }
 export async function fetchOliveyoungProducts(params, options = {}) {
     const payload = {
@@ -182,11 +217,11 @@ export async function fetchOliveyoungProducts(params, options = {}) {
             nextPage: Boolean(body.data?.nextPage),
             products,
         };
-        writeStaleOliveyoungProductSearchResult(cacheKey, result);
+        writeStaleResult(oliveyoungProductSearchCache, cacheKey, result, cloneOliveyoungProductSearchResult);
         return result;
     }
     catch (error) {
-        const staleResult = readStaleOliveyoungProductSearchResult(cacheKey);
+        const staleResult = readStaleResult(oliveyoungProductSearchCache, cacheKey, cloneOliveyoungProductSearchResult);
         if (staleResult) {
             return staleResult;
         }
@@ -214,25 +249,37 @@ async function fetchOliveyoungProductId(goodsNumber, options = {}) {
     return productId;
 }
 async function fetchOliveyoungStockStores(params, options = {}) {
-    const body = await zyteExtract(OLIVEYOUNG_API.STOCK_STORES_PATH, {
-        productId: params.productId,
-        lat: params.latitude,
-        lon: params.longitude,
-        pageIdx: params.pageIdx,
-        searchWords: params.searchWords,
-        mapLat: params.latitude,
-        mapLon: params.longitude,
-    }, options);
-    const stores = (body.data?.storeList || []).map((store) => resolveOliveyoungStoreStock(store));
-    const inStockCount = stores.filter((store) => store.stockStatus === 'in_stock').length;
-    const notSoldCount = stores.filter((store) => store.stockStatus === 'not_sold').length;
-    return {
-        totalCount: body.data?.totalCount || 0,
-        inStockCount,
-        outOfStockCount: stores.length - inStockCount - notSoldCount,
-        notSoldCount,
-        stores,
-    };
+    const cacheKey = createOliveyoungStockStoresCacheKey(params);
+    try {
+        const body = await zyteExtract(OLIVEYOUNG_API.STOCK_STORES_PATH, {
+            productId: params.productId,
+            lat: params.latitude,
+            lon: params.longitude,
+            pageIdx: params.pageIdx,
+            searchWords: params.searchWords,
+            mapLat: params.latitude,
+            mapLon: params.longitude,
+        }, options);
+        const stores = (body.data?.storeList || []).map((store) => resolveOliveyoungStoreStock(store));
+        const inStockCount = stores.filter((store) => store.stockStatus === 'in_stock').length;
+        const notSoldCount = stores.filter((store) => store.stockStatus === 'not_sold').length;
+        const result = {
+            totalCount: body.data?.totalCount || 0,
+            inStockCount,
+            outOfStockCount: stores.length - inStockCount - notSoldCount,
+            notSoldCount,
+            stores,
+        };
+        writeStaleResult(oliveyoungStockStoresCache, cacheKey, result, cloneOliveyoungStockStoresResult);
+        return result;
+    }
+    catch (error) {
+        const staleResult = readStaleResult(oliveyoungStockStoresCache, cacheKey, cloneOliveyoungStockStoresResult);
+        if (staleResult) {
+            return staleResult;
+        }
+        throw error;
+    }
 }
 function sortOliveyoungProducts(products) {
     const score = (product) => {
@@ -299,4 +346,6 @@ export async function enrichOliveyoungProductsWithNearbyStoreInventory(products,
 export function __testOnlyClearOliveyoungCaches() {
     oliveyoungProductIdCache.clear();
     oliveyoungProductSearchCache.clear();
+    oliveyoungStoreSearchCache.clear();
+    oliveyoungStockStoresCache.clear();
 }

package/dist/services/places/client.js

@@ -0,0 +1,116 @@
+const CATEGORY_KEYWORDS = {
+    restaurant: '음식점',
+    cafe: '카페',
+    food: '음식점',
+    dessert: '디저트',
+    all: '',
+};
+function getProcessEnvValue(name) {
+    /* c8 ignore next -- Node 테스트와 CLI 런타임은 process를 제공하며, Worker에는 API에서 키를 주입합니다. */
+    return typeof process !== 'undefined' ? process.env[name] : undefined;
+}
+function cleanHtml(value) {
+    if (!value) {
+        return '';
+    }
+    return value
+        .replace(/<[^>]*>/g, '')
+        .replace(/&amp;/g, '&')
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&quot;/g, '"')
+        .replace(/&#39;/g, "'")
+        .trim();
+}
+function toCoordinate(value) {
+    if (!value) {
+        return null;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed)) {
+        return null;
+    }
+    return parsed / 10000000;
+}
+function clampDisplay(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return 5;
+    }
+    return Math.min(Math.max(Math.trunc(value), 1), 5);
+}
+function clampStart(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return 1;
+    }
+    return Math.min(Math.max(Math.trunc(value), 1), 1000);
+}
+export function buildNaverLocalQuery({ location = '', keyword = '', category = 'all', }) {
+    const parts = [location.trim(), keyword.trim() || CATEGORY_KEYWORDS[category]].filter((part) => part.length > 0);
+    return parts.join(' ').trim();
+}
+function normalizePlace(item) {
+    return {
+        name: cleanHtml(item.title),
+        category: cleanHtml(item.category),
+        address: cleanHtml(item.address),
+        roadAddress: cleanHtml(item.roadAddress),
+        phone: cleanHtml(item.telephone),
+        link: item.link,
+        longitude: toCoordinate(item.mapx),
+        latitude: toCoordinate(item.mapy),
+        raw: item,
+    };
+}
+export async function searchNaverLocalPlaces(args) {
+    const naverClientId = args.naverClientId?.trim() || getProcessEnvValue('NAVER_CLIENT_ID')?.trim();
+    const naverClientSecret = args.naverClientSecret?.trim() || getProcessEnvValue('NAVER_CLIENT_SECRET')?.trim();
+    if (!naverClientId || !naverClientSecret) {
+        throw new Error('NAVER_CLIENT_ID와 NAVER_CLIENT_SECRET 환경 변수가 필요합니다.');
+    }
+    const category = args.category ?? 'all';
+    const location = args.location?.trim() ?? '';
+    const query = buildNaverLocalQuery({
+        location,
+        keyword: args.keyword,
+        category,
+    });
+    if (query.length === 0) {
+        throw new Error('위치(location) 또는 검색어(keyword)를 입력해주세요.');
+    }
+    const url = new URL('https://openapi.naver.com/v1/search/local.json');
+    url.searchParams.set('query', query);
+    url.searchParams.set('display', String(clampDisplay(args.limit)));
+    url.searchParams.set('start', String(clampStart(args.start)));
+    url.searchParams.set('sort', args.sort ?? 'random');
+    const fetchImpl = args.fetchImpl ?? fetch;
+    const response = await fetchImpl(url.toString(), {
+        headers: {
+            'X-Naver-Client-Id': naverClientId,
+            'X-Naver-Client-Secret': naverClientSecret,
+        },
+        signal: AbortSignal.timeout(args.timeoutMs ?? 10000),
+    });
+    const bodyText = await response.text();
+    let parsed;
+    try {
+        parsed = JSON.parse(bodyText);
+    }
+    catch {
+        parsed = {};
+    }
+    if (!response.ok) {
+        const message = parsed.errorMessage || bodyText || `HTTP ${response.status}`;
+        throw new Error(`네이버 지역 검색 실패: ${message}`);
+    }
+    const places = (parsed.items ?? []).map(normalizePlace);
+    return {
+        provider: 'naverLocal',
+        searchMode: 'keyword',
+        query,
+        category,
+        location,
+        totalCount: parsed.total ?? places.length,
+        count: places.length,
+        places,
+    };
+}

package/dist/services/places/index.js

@@ -0,0 +1,23 @@
+import { createSearchNearbyPlacesTool } from './tools/searchNearby.js';
+const PLACES_METADATA = {
+    id: 'places',
+    name: '장소 검색',
+    version: '1.0.0',
+    description: '네이버 지역 검색 기반 음식점, 카페, 주변 장소 탐색 서비스',
+};
+class PlacesService {
+    options;
+    metadata = PLACES_METADATA;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    getTools() {
+        return [
+            createSearchNearbyPlacesTool(this.options.naverClientId, this.options.naverClientSecret),
+        ];
+    }
+}
+export function createPlacesService(options = {}) {
+    return new PlacesService(options);
+}
+export * from './types.js';

package/dist/services/places/tools/searchNearby.js

@@ -0,0 +1,56 @@
+/**
+ * 네이버 지역 검색 기반 주변 장소 탐색 도구
+ */
+import * as z from 'zod';
+import { searchNaverLocalPlaces } from '../client.js';
+async function searchNearbyPlaces(args) {
+    const result = await searchNaverLocalPlaces(args);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(result, null, 2),
+            },
+        ],
+        structuredContent: result,
+    };
+}
+export function createSearchNearbyPlacesTool(naverClientId, naverClientSecret) {
+    return {
+        name: 'places_search_nearby',
+        metadata: {
+            title: '주변 음식점/카페 검색',
+            description: '네이버 지역 검색으로 특정 지역의 음식점, 카페, 디저트 가게 등 주변 장소를 키워드 기반으로 찾습니다.',
+            inputSchema: {
+                location: z.string().optional().describe('지역/역/주소 키워드 (예: 강남역, 성수동)'),
+                keyword: z.string().optional().describe('검색어 (예: 라멘, 브런치, 조용한 카페)'),
+                category: z
+                    .enum(['restaurant', 'cafe', 'food', 'dessert', 'all'])
+                    .optional()
+                    .default('all')
+                    .describe('장소 카테고리. restaurant/food=음식점, cafe=카페, dessert=디저트'),
+                limit: z
+                    .number()
+                    .optional()
+                    .default(5)
+                    .describe('반환할 최대 장소 수 (네이버 지역 검색 최대 5)'),
+                start: z.number().optional().default(1).describe('검색 시작 위치 (기본값: 1)'),
+                sort: z
+                    .enum(['random', 'comment'])
+                    .optional()
+                    .default('random')
+                    .describe('정렬 방식. random=유사도순, comment=리뷰순'),
+                timeoutMs: z
+                    .number()
+                    .optional()
+                    .default(10000)
+                    .describe('요청 제한 시간(ms, 기본값: 10000)'),
+            },
+        },
+        handler: ((args) => searchNearbyPlaces({
+            ...args,
+            naverClientId: args.naverClientId || naverClientId,
+            naverClientSecret: args.naverClientSecret || naverClientSecret,
+        })),
+    };
+}

package/dist/services/places/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/zyte.js

@@ -40,6 +40,17 @@ export function decodeBase64(value) {
 function isAbortError(error) {
     return error instanceof Error && error.name === 'AbortError';
 }
+class RetryableZyteError extends Error {
+}
+function isRetryableZyteStatus(status) {
+    return status === 408 || status === 429 || status >= 500;
+}
+function isRetryableTargetStatus(statusCode) {
+    return typeof statusCode === 'number' && statusCode >= 500;
+}
+function isRetryableError(error) {
+    return isAbortError(error) || error instanceof RetryableZyteError;
+}
 function wait(ms) {
     if (ms <= 0) {
         return Promise.resolve();
@@ -55,30 +66,46 @@ export async function requestByZyte(options) {
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
         const { controller, timeoutId } = createTimeoutController(timeout);
         try {
-            const response = await fetch('https://api.zyte.com/v1/extract', {
-                method: 'POST',
-                headers: {
-                    Authorization: `Basic ${auth}`,
-                    'Content-Type': 'application/json',
-                    Accept: 'application/json',
-                },
-                body: JSON.stringify({
-                    url,
-                    httpRequestMethod: method,
-                    customHttpRequestHeaders: headers,
-                    httpRequestText: bodyText,
-                    httpResponseBody: true,
-                }),
-                signal: controller.signal,
-            });
+            let response;
+            try {
+                response = await fetch('https://api.zyte.com/v1/extract', {
+                    method: 'POST',
+                    headers: {
+                        Authorization: `Basic ${auth}`,
+                        'Content-Type': 'application/json',
+                        Accept: 'application/json',
+                    },
+                    body: JSON.stringify({
+                        url,
+                        httpRequestMethod: method,
+                        customHttpRequestHeaders: headers,
+                        httpRequestText: bodyText,
+                        httpResponseBody: true,
+                    }),
+                    signal: controller.signal,
+                });
+            }
+            catch (error) {
+                if (error instanceof TypeError) {
+                    throw new RetryableZyteError(error.message);
+                }
+                throw error;
+            }
             const result = (await response.json());
             if (!response.ok) {
-                throw new Error(`Zyte API 호출 실패: ${response.status} ${result.detail || result.title || ''}`.trim());
+                const message = `Zyte API 호출 실패: ${response.status} ${result.detail || result.title || ''}`.trim();
+                if (isRetryableZyteStatus(response.status)) {
+                    throw new RetryableZyteError(message);
+                }
+                throw new Error(message);
+            }
+            if (isRetryableTargetStatus(result.statusCode) && attempt < maxAttempts) {
+                throw new RetryableZyteError(`Zyte target response failed: ${result.statusCode}`);
             }
             return result;
         }
         catch (error) {
-            if (!isAbortError(error) || attempt >= maxAttempts) {
+            if (!isRetryableError(error) || attempt >= maxAttempts) {
                 throw error;
             }
             await wait(retryDelayMs);

package/openapi.json

@@ -53,6 +53,8 @@
                 "sevenelevenCheckInventory",
                 "sevenelevenGetPopwords",
                 "sevenelevenGetCatalog",
+                "compareProducts",
+                "placesSearchNearby",
                 "megaboxFindTheaters",
                 "megaboxListMovies",
                 "megaboxGetSeats",
@@ -110,6 +112,33 @@
               "type": "string"
             }
           },
+          {
+            "name": "location",
+            "in": "query",
+            "required": false,
+            "description": "주변 장소 검색 지역/역/주소 키워드",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "category",
+            "in": "query",
+            "required": false,
+            "description": "주변 장소 카테고리(restaurant, cafe, food, dessert, all)",
+            "schema": {
+              "type": "string"
+            }
+          },
+          {
+            "name": "services",
+            "in": "query",
+            "required": false,
+            "description": "통합 비교 서비스 목록(daiso,gs25,seveneleven,emart24)",
+            "schema": {
+              "type": "string"
+            }
+          },
           {
             "name": "sido",
             "in": "query",

package/openapi.yaml

@@ -54,6 +54,8 @@ paths:
               - sevenelevenCheckInventory
               - sevenelevenGetPopwords
               - sevenelevenGetCatalog
+              - compareProducts
+              - placesSearchNearby
               - megaboxFindTheaters
               - megaboxListMovies
               - megaboxGetSeats
@@ -93,6 +95,24 @@ paths:
           description: 공통 키워드 파라미터
           schema:
             type: string
+        - name: location
+          in: query
+          required: false
+          description: 주변 장소 검색 지역/역/주소 키워드
+          schema:
+            type: string
+        - name: category
+          in: query
+          required: false
+          description: 주변 장소 카테고리(restaurant, cafe, food, dessert, all)
+          schema:
+            type: string
+        - name: services
+          in: query
+          required: false
+          description: 통합 비교 서비스 목록(daiso,gs25,seveneleven,emart24)
+          schema:
+            type: string
         - name: sido
           in: query
           required: false