daiso 1.0.4 → 1.0.5

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

@@ -5,7 +5,23 @@
  */
 import * as z from 'zod';
 import { DAISOMALL_API } from '../api.js';
-import { fetchDaisoJson } from '../client.js';
+import { fetchDaisoJson, fetchDaisoJsonWithAuth } from '../client.js';
+import { buildDaisoStoreKeywordVariants } from '../../../utils/daisoKeyword.js';
+import { fetchProductById } from './getPriceInfo.js';
+import { toProductSummary } from '../product.js';
+/**
+ * 재고 응답에 함께 노출할 상품 요약 정보를 조회합니다.
+ * 부가 정보이므로 실패해도 전체 재고 조회는 계속 진행합니다.
+ */
+async function fetchInventoryProduct(productId) {
+    try {
+        const product = await fetchProductById(productId);
+        return product ? toProductSummary(product) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * 온라인 재고 조회
  */
@@ -24,46 +40,63 @@ export async function fetchOnlineStock(productNo) {
  * 매장별 재고 조회
  */
 export async function fetchStoreInventory(productNo, lat, lng, page = 1, pageSize = 30, keyword = '') {
-    const data = await fetchDaisoJson(DAISOMALL_API.STORE_INVENTORY, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            keyword,
-            pdNo: productNo,
-            curLttd: lat,
-            curLitd: lng,
-            geolocationAgrYn: 'Y',
-            pkupYn: '',
-            intCd: '',
-            pageSize,
-            currentPage: page,
-        }),
-    });
-    if (!data.success || !data.data?.msStrVOList) {
-        return { stores: [], totalCount: 0 };
+    const searchKeywords = keyword ? buildDaisoStoreKeywordVariants(keyword) : [''];
+    for (const searchKeyword of searchKeywords) {
+        const storeSearch = await fetchDaisoJson(DAISOMALL_API.STORE_SEARCH_V2, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                inclusiveStrCd: '',
+                keyword: searchKeyword,
+                curLttd: lat,
+                curLitd: lng,
+            }),
+        });
+        const allStores = storeSearch.data || [];
+        const searchedStores = allStores.slice((page - 1) * pageSize, page * pageSize);
+        if (searchedStores.length === 0) {
+            if (searchKeyword === searchKeywords[searchKeywords.length - 1]) {
+                return { stores: [], totalCount: 0 };
+            }
+            continue;
+        }
+        const inventoryResponse = await fetchDaisoJsonWithAuth(DAISOMALL_API.STORE_INVENTORY_V2, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(searchedStores.map((store) => ({
+                pdNo: productNo,
+                strCd: store.strCd,
+            }))),
+        });
+        const quantities = new Map((inventoryResponse.data || []).map((item) => [item.strCd, parseInt(item.stck) || 0]));
+        const stores = searchedStores.map((store) => ({
+            storeCode: store.strCd,
+            storeName: store.strNm,
+            address: store.strAddr,
+            phone: store.strTno,
+            openTime: store.opngTime,
+            closeTime: store.clsngTime,
+            lat: store.strLttd,
+            lng: store.strLitd,
+            distance: store.km,
+            quantity: quantities.get(store.strCd) ?? 0,
+            options: {
+                parking: store.parkYn === 'Y',
+                simCard: store.usimYn === 'Y',
+                pickup: store.pkupYn === 'Y',
+                taxFree: store.taxfYn === 'Y',
+                elevator: store.elvtYn === 'Y',
+                ramp: store.entrRampYn === 'Y',
+                cashless: store.nocashYn === 'Y',
+            },
+        }));
+        return {
+            stores,
+            totalCount: allStores.length,
+        };
     }
-    const stores = data.data.msStrVOList.map((store) => ({
-        storeCode: store.strCd,
-        storeName: store.strNm,
-        address: store.strAddr,
-        phone: store.strTno,
-        openTime: store.opngTime,
-        closeTime: store.clsngTime,
-        lat: store.strLttd,
-        lng: store.strLitd,
-        distance: store.km,
-        quantity: parseInt(store.qty) || 0,
-        options: {
-            parking: store.parkYn === 'Y',
-            simCard: store.usimYn === 'Y',
-            pickup: store.pkupYn === 'Y',
-            taxFree: store.taxfYn === 'Y',
-            elevator: store.elvtYn === 'Y',
-            ramp: store.entrRampYn === 'Y',
-            cashless: store.nocashYn === 'Y',
-        },
-    }));
-    return { stores, totalCount: data.data.intStrCont || stores.length };
+    /* c8 ignore next -- searchKeywords is always non-empty; this is a defensive fallback. */
+    return { stores: [], totalCount: 0 };
 }
 /**
  * 재고 확인 핸들러
@@ -75,15 +108,17 @@ async function checkInventory(args) {
         throw new Error('상품 ID(productId)를 입력해주세요.');
     }
     // 온라인 재고와 매장 재고 동시 조회
-    const [onlineStock, storeResult] = await Promise.all([
+    const [onlineStock, storeResult, product] = await Promise.all([
         fetchOnlineStock(productId),
         fetchStoreInventory(productId, latitude, longitude, page, pageSize, storeQuery),
+        fetchInventoryProduct(productId),
     ]);
     // 재고 있는 매장과 없는 매장 분류
     const inStockStores = storeResult.stores.filter((s) => s.quantity > 0);
     const outOfStockStores = storeResult.stores.filter((s) => s.quantity === 0);
     const result = {
         productId,
+        product,
         location: { latitude, longitude },
         onlineStock,
         storeInventory: {

package/dist/services/daiso/tools/findStores.js

@@ -6,6 +6,7 @@
 import * as z from 'zod';
 import { DAISO_WEB_API, formatTime } from '../api.js';
 import { fetchDaisoHtml, fetchDaisoJson } from '../client.js';
+import { buildDaisoStoreKeywordVariants } from '../../../utils/daisoKeyword.js';
 /**
  * HTML에서 매장 정보 파싱
  */
@@ -75,13 +76,22 @@ function parseStoresFromHtml(html) {
  * 다이소 매장 검색 API 호출
  */
 export async function fetchStores(keyword, sido, gugun, dong) {
-    const url = new URL(DAISO_WEB_API.SHOP_SEARCH);
-    url.searchParams.set('name_address', keyword || '');
-    url.searchParams.set('sido', sido || '');
-    url.searchParams.set('gugun', gugun || '');
-    url.searchParams.set('dong', dong || '');
-    const html = await fetchDaisoHtml(url.toString());
-    return parseStoresFromHtml(html);
+    const searchKeywords = keyword && !sido && !gugun && !dong
+        ? buildDaisoStoreKeywordVariants(keyword)
+        : [keyword || ''];
+    for (const searchKeyword of searchKeywords) {
+        const url = new URL(DAISO_WEB_API.SHOP_SEARCH);
+        url.searchParams.set('name_address', searchKeyword);
+        url.searchParams.set('sido', sido || '');
+        url.searchParams.set('gugun', gugun || '');
+        url.searchParams.set('dong', dong || '');
+        const html = await fetchDaisoHtml(url.toString());
+        const stores = parseStoresFromHtml(html);
+        if (stores.length > 0) {
+            return stores;
+        }
+    }
+    return [];
 }
 /**
  * 시/도별 구/군 목록 조회

package/dist/services/daiso/tools/getDisplayLocation.js

@@ -0,0 +1,75 @@
+/**
+ * 진열 위치 조회 도구
+ *
+ * 다이소몰 API를 사용하여 매장 내 상품 진열 위치(구역/층)를 조회합니다.
+ */
+import * as z from 'zod';
+import { DAISOMALL_API } from '../api.js';
+import { fetchDaisoJsonWithAuth } from '../client.js';
+/**
+ * 매장 내 상품 진열 위치 조회
+ */
+export async function fetchDisplayLocation(productId, storeCode) {
+    const data = await fetchDaisoJsonWithAuth(DAISOMALL_API.DISPLAY_LOCATION, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ pdNo: productId, strCd: storeCode }),
+    });
+    if (!data.success) {
+        return {
+            productId,
+            storeCode,
+            hasLocation: false,
+            locations: [],
+            message: data.message ?? null,
+        };
+    }
+    const locations = Array.isArray(data.data)
+        ? data.data.map((item) => ({
+            zoneNo: String(item.zoneNo ?? ''),
+            stairNo: String(item.stairNo ?? ''),
+            storeErp: String(item.storeErp ?? storeCode),
+        }))
+        : [];
+    return {
+        productId,
+        storeCode,
+        hasLocation: locations.length > 0,
+        locations,
+    };
+}
+/**
+ * 진열 위치 조회 핸들러
+ */
+async function getDisplayLocation(args) {
+    const { productId, storeCode } = args;
+    if (!productId || productId.trim().length === 0) {
+        throw new Error('상품 ID(productId)를 입력해주세요.');
+    }
+    if (!storeCode || storeCode.trim().length === 0) {
+        throw new Error('매장 코드(storeCode)를 입력해주세요.');
+    }
+    const result = await fetchDisplayLocation(productId, storeCode);
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+}
+/**
+ * 도구 등록 정보 생성
+ */
+export function createGetDisplayLocationTool() {
+    return {
+        name: 'daiso_get_display_location',
+        metadata: {
+            title: '진열 위치 조회',
+            description: '다이소 매장 내 상품의 진열 위치(구역/층)를 조회합니다. 상품 ID와 매장 코드가 필요합니다.',
+            inputSchema: {
+                productId: z.string().describe('상품 ID (daiso_search_products로 조회한 상품의 id)'),
+                storeCode: z
+                    .string()
+                    .describe('매장 코드 (daiso_check_inventory로 조회한 매장의 storeCode)'),
+            },
+        },
+        handler: getDisplayLocation,
+    };
+}

package/dist/services/emart24/api.js

@@ -0,0 +1,11 @@
+/**
+ * 이마트24 API 엔드포인트 중앙 관리
+ */
+export const EMART24_API = {
+    WEB_BASE_URL: 'https://emart24.co.kr',
+    EVERSE_BASE_URL: 'https://everse.emart24.co.kr',
+    STORE_PATH: '/api1/store',
+    PRODUCT_SEARCH_PATH: '/stock/stock/search',
+    STOCK_SEARCH_STORE_PATH: '/api/stock/v2/stock-search/store',
+    STORE_DETAIL_PATH_PREFIX: '/api/stock/stock/store/',
+};

package/dist/services/emart24/client.js

@@ -0,0 +1,173 @@
+/**
+ * 이마트24 API 클라이언트
+ */
+import { fetchJson } from '../../utils/http.js';
+import { EMART24_API } from './api.js';
+const EMART24_JSON_HEADERS = {
+    Accept: 'application/json, text/javascript, */*; q=0.01',
+    'X-Requested-With': 'XMLHttpRequest',
+};
+const EMART24_FORM_HEADERS = {
+    'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+    Accept: 'application/json, text/javascript, */*; q=0.01',
+    'X-Requested-With': 'XMLHttpRequest',
+};
+function buildKeywordVariants(keyword) {
+    const trimmed = keyword.trim();
+    if (trimmed.length === 0) {
+        return [''];
+    }
+    const tokens = trimmed.split(/\s+/).filter((token) => token.length > 0);
+    const variants = [
+        trimmed,
+        trimmed.replace(/\s+/g, ''),
+        ...tokens,
+        ...tokens.map((token) => token.replace(/역$/, '')),
+    ].filter((value) => value.length > 0);
+    return [...new Set(variants)];
+}
+function toNumber(value) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number.parseFloat(value);
+        return Number.isFinite(parsed) ? parsed : 0;
+    }
+    return 0;
+}
+function toBooleanFlag(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    const normalized = String(value || '').trim().toUpperCase();
+    return normalized === '1' || normalized === 'Y' || normalized === 'TRUE';
+}
+function toStore(item) {
+    return {
+        storeCode: item.CODE || '',
+        storeName: item.TITLE || '',
+        address: item.ADDRESS || '',
+        addressDetail: item.ADDRESS_DE || '',
+        phone: item.PHONE || '',
+        latitude: toNumber(item.LATITUDE),
+        longitude: toNumber(item.LONGITUDE),
+        openTime: item.START_HHMM || '',
+        closeTime: item.END_HHMM || '',
+        openDate: item.OPEN_DATE || '',
+        endDate: item.END_DATE || '',
+        service24h: toBooleanFlag(item.SVR_24),
+        distanceM: null,
+    };
+}
+function toProduct(item) {
+    return {
+        pluCd: item.pluCd || '',
+        goodsName: item.goodsNm || '',
+        originPrice: toNumber(item.originPrice),
+        viewPrice: toNumber(item.viewPrice),
+        category: item.categoryNm || '',
+        kind: item.kindNm || '',
+    };
+}
+export function calculateDistanceM(lat1, lng1, lat2, lng2) {
+    const toRad = (deg) => (deg * Math.PI) / 180;
+    const dLat = toRad(lat2 - lat1);
+    const dLng = toRad(lng2 - lng1);
+    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLng / 2) * Math.sin(dLng / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    return Math.round(6371000 * c);
+}
+export async function fetchEmart24Stores(params = {}, options = {}) {
+    const { timeout = 15000 } = options;
+    const { keyword = '', area1 = '', area2 = '', page = 1, service24h = false } = params;
+    const keywordVariants = buildKeywordVariants(keyword);
+    let lastError;
+    for (let index = 0; index < keywordVariants.length; index += 1) {
+        const searchKeyword = keywordVariants[index];
+        const endpoint = new URL(EMART24_API.STORE_PATH, EMART24_API.WEB_BASE_URL);
+        endpoint.searchParams.set('page', String(page));
+        if (searchKeyword.length > 0) {
+            endpoint.searchParams.set('search', searchKeyword);
+        }
+        if (area1.trim().length > 0) {
+            endpoint.searchParams.set('AREA1', area1.trim());
+        }
+        if (area2.trim().length > 0) {
+            endpoint.searchParams.set('AREA2', area2.trim());
+        }
+        if (service24h) {
+            endpoint.searchParams.set('SVR_24', '1');
+        }
+        const body = await fetchJson(endpoint.toString(), {
+            method: 'GET',
+            timeout,
+            headers: EMART24_JSON_HEADERS,
+        });
+        if (body.error === 0 || body.error === undefined) {
+            const stores = (body.data || []).map(toStore).filter((store) => store.storeCode.length > 0);
+            return {
+                totalCount: toNumber(body.count),
+                stores,
+                appliedKeyword: searchKeyword,
+            };
+        }
+        lastError = body.error;
+        const hasMoreVariants = index < keywordVariants.length - 1;
+        if (body.error !== 1 || !hasMoreVariants) {
+            break;
+        }
+    }
+    throw new Error(`이마트24 매장 조회 실패: error=${lastError}`);
+}
+export async function searchEmart24Products(params, options = {}) {
+    const { keyword, page = 1, pageSize = 10, sortType = 'SALE', saleProductYn = 'N', } = params;
+    const { timeout = 15000 } = options;
+    const form = new URLSearchParams();
+    form.set('currentPage', String(page));
+    form.set('pageCnt', String(pageSize));
+    form.set('sortType', sortType);
+    form.set('saleProductYn', saleProductYn);
+    form.set('searchWord', keyword.trim());
+    const body = await fetchJson(`${EMART24_API.EVERSE_BASE_URL}${EMART24_API.PRODUCT_SEARCH_PATH}`, {
+        method: 'POST',
+        timeout,
+        headers: EMART24_FORM_HEADERS,
+        body: form.toString(),
+    });
+    const products = (body.productList || []).map(toProduct).filter((item) => item.pluCd.length > 0);
+    return {
+        totalCount: toNumber(body.totalCnt),
+        products,
+    };
+}
+export async function searchEmart24StockByStores(params, options = {}) {
+    const { timeout = 15000 } = options;
+    const { pluCd, bizNos } = params;
+    const filteredBizNos = bizNos.map((value) => value.trim()).filter((value) => value.length > 0);
+    if (filteredBizNos.length === 0) {
+        return {
+            storeGoodsInfo: {
+                pluCd,
+            },
+            storeGoodsQty: [],
+        };
+    }
+    const endpoint = new URL(EMART24_API.STOCK_SEARCH_STORE_PATH, EMART24_API.EVERSE_BASE_URL);
+    endpoint.searchParams.set('searchPluCode', pluCd);
+    endpoint.searchParams.set('bizNoArr', filteredBizNos.join(','));
+    return fetchJson(endpoint.toString(), {
+        method: 'GET',
+        timeout,
+        headers: EMART24_JSON_HEADERS,
+    });
+}
+export async function fetchEmart24StoreDetail(bizNo, options = {}) {
+    const { timeout = 15000 } = options;
+    return fetchJson(`${EMART24_API.EVERSE_BASE_URL}${EMART24_API.STORE_DETAIL_PATH_PREFIX}${encodeURIComponent(bizNo)}`, {
+        method: 'GET',
+        timeout,
+        headers: EMART24_JSON_HEADERS,
+    });
+}

package/dist/services/emart24/index.js

@@ -0,0 +1,22 @@
+/**
+ * 이마트24 서비스 프로바이더
+ */
+import { createFindNearbyStoresTool } from './tools/findNearbyStores.js';
+import { createSearchProductsTool } from './tools/searchProducts.js';
+import { createCheckInventoryTool } from './tools/checkInventory.js';
+const EMART24_METADATA = {
+    id: 'emart24',
+    name: '이마트24',
+    version: '1.0.0',
+    description: '이마트24 매장 탐색, 상품 검색, 매장별 재고 조회 서비스',
+};
+class Emart24Service {
+    metadata = EMART24_METADATA;
+    getTools() {
+        return [createFindNearbyStoresTool(), createSearchProductsTool(), createCheckInventoryTool()];
+    }
+}
+export function createEmart24Service() {
+    return new Emart24Service();
+}
+export * from './types.js';

package/dist/services/emart24/inventoryLookup.js

@@ -0,0 +1,134 @@
+/**
+ * 이마트24 재고 조회 공통 로직
+ */
+import { calculateDistanceM, fetchEmart24StoreDetail, fetchEmart24Stores, searchEmart24Products, searchEmart24StockByStores, } from './client.js';
+async function resolvePluCd(pluCd, keyword, productPage, productPageSize, timeoutMs) {
+    const normalizedPluCd = (pluCd || '').trim();
+    if (normalizedPluCd.length > 0) {
+        return {
+            pluCd: normalizedPluCd,
+            products: [],
+        };
+    }
+    if (keyword.trim().length === 0) {
+        throw new Error('pluCd 또는 keyword 중 하나는 반드시 입력해주세요.');
+    }
+    const productResult = await searchEmart24Products({
+        keyword,
+        page: productPage,
+        pageSize: productPageSize,
+    }, {
+        timeout: timeoutMs,
+    });
+    const firstProduct = productResult.products.find((item) => item.pluCd.trim().length > 0);
+    if (!firstProduct) {
+        throw new Error('상품 검색 결과에서 PLU 코드를 찾을 수 없습니다.');
+    }
+    return {
+        pluCd: firstProduct.pluCd,
+        products: productResult.products,
+    };
+}
+function sortStoresByDistance(stores, latitude, longitude) {
+    return [...stores]
+        .map((store) => {
+        if (typeof latitude !== 'number' ||
+            typeof longitude !== 'number' ||
+            store.latitude === 0 ||
+            store.longitude === 0) {
+            return {
+                store,
+                sortDistance: Number.MAX_SAFE_INTEGER,
+            };
+        }
+        const distanceM = calculateDistanceM(latitude, longitude, store.latitude, store.longitude);
+        return {
+            store: {
+                ...store,
+                distanceM,
+            },
+            sortDistance: distanceM,
+        };
+    })
+        .sort((a, b) => a.sortDistance - b.sortDistance)
+        .map((entry) => entry.store);
+}
+export async function lookupEmart24Inventory(args) {
+    const { pluCd, keyword = '', latitude, longitude, storeKeyword = '', area1 = '', area2 = '', service24h = false, productPage = 1, productPageSize = 10, storeLimit = 10, timeoutMs = 15000, bizNos = [], includeRequestedStoresWithoutQty = false, } = args;
+    const resolved = await resolvePluCd(pluCd, keyword, productPage, productPageSize, timeoutMs);
+    const normalizedBizNos = [...new Set(bizNos.map((value) => value.trim()).filter((value) => value.length > 0))];
+    let nearbyStores = [];
+    let nearbyTotalCount = normalizedBizNos.length;
+    let appliedStoreKeyword = storeKeyword;
+    if (normalizedBizNos.length === 0) {
+        const nearbyStoreResult = await fetchEmart24Stores({
+            keyword: storeKeyword,
+            area1,
+            area2,
+            service24h,
+            page: 1,
+        }, {
+            timeout: timeoutMs,
+        });
+        appliedStoreKeyword = nearbyStoreResult.appliedKeyword;
+        nearbyTotalCount = nearbyStoreResult.totalCount;
+        nearbyStores = sortStoresByDistance(nearbyStoreResult.stores, latitude, longitude).slice(0, storeLimit);
+    }
+    const requestedBizNos = normalizedBizNos.length > 0 ? normalizedBizNos : nearbyStores.map((store) => store.storeCode);
+    const stockResult = await searchEmart24StockByStores({
+        pluCd: resolved.pluCd,
+        bizNos: requestedBizNos,
+    }, {
+        timeout: timeoutMs,
+    });
+    const qtyByBizNo = new Map((stockResult.storeGoodsQty || []).map((item) => [
+        String(item.BIZNO || '').trim(),
+        Number.parseInt(String(item.BIZQTY || 0), 10) || 0,
+    ]));
+    const inventoryBizNos = includeRequestedStoresWithoutQty && requestedBizNos.length > 0
+        ? requestedBizNos
+        : (stockResult.storeGoodsQty || [])
+            .map((item) => String(item.BIZNO || '').trim())
+            .filter((value) => value.length > 0);
+    const detailResults = await Promise.allSettled(inventoryBizNos.map((bizNo) => fetchEmart24StoreDetail(bizNo, { timeout: timeoutMs })));
+    const nearbyStoreByCode = new Map(nearbyStores.map((store) => [store.storeCode, store]));
+    const stores = inventoryBizNos.map((bizNo, index) => {
+        const detail = detailResults[index];
+        const detailInfo = detail.status === 'fulfilled' ? detail.value.storeInfo : undefined;
+        const nearby = nearbyStoreByCode.get(bizNo);
+        return {
+            bizNo,
+            bizQty: qtyByBizNo.get(bizNo) ?? 0,
+            storeName: detailInfo?.storeNm || nearby?.storeName || '',
+            address: detailInfo?.storeAddr || nearby?.address || '',
+            phone: detailInfo?.tel || nearby?.phone || '',
+            distanceM: nearby?.distanceM ?? null,
+        };
+    });
+    return {
+        keyword,
+        pluCd: resolved.pluCd,
+        productCandidates: resolved.products,
+        location: typeof latitude === 'number' && typeof longitude === 'number'
+            ? { latitude, longitude }
+            : null,
+        storeFilters: {
+            storeKeyword,
+            appliedStoreKeyword,
+            area1,
+            area2,
+            service24h,
+            storeLimit,
+            directBizNos: normalizedBizNos,
+        },
+        nearbyStores: {
+            totalCount: nearbyTotalCount,
+            stores: nearbyStores,
+        },
+        inventory: {
+            goodsInfo: stockResult.storeGoodsInfo || null,
+            count: stores.length,
+            stores,
+        },
+    };
+}

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

@@ -0,0 +1,54 @@
+/**
+ * 이마트24 재고 확인 도구
+ */
+import * as z from 'zod';
+import { lookupEmart24Inventory } from '../inventoryLookup.js';
+async function checkInventory(args) {
+    const { pluCd, keyword = '', latitude, longitude, storeKeyword = '', area1 = '', area2 = '', service24h = false, productPage = 1, productPageSize = 10, storeLimit = 10, timeoutMs = 15000, } = args;
+    const result = await lookupEmart24Inventory({
+        pluCd,
+        keyword,
+        latitude,
+        longitude,
+        storeKeyword,
+        area1,
+        area2,
+        service24h,
+        productPage,
+        productPageSize,
+        storeLimit,
+        timeoutMs,
+    });
+    return {
+        content: [
+            {
+                type: 'text',
+                text: JSON.stringify(result, null, 2),
+            },
+        ],
+    };
+}
+export function createCheckInventoryTool() {
+    return {
+        name: 'emart24_check_inventory',
+        metadata: {
+            title: '이마트24 재고 확인',
+            description: 'PLU 코드 또는 상품 키워드로 매장별 재고 수량을 조회합니다.',
+            inputSchema: {
+                pluCd: z.string().optional().describe('상품 PLU 코드 (예: 8800244010504)'),
+                keyword: z.string().optional().describe('상품 검색어 (pluCd 미입력 시 필수)'),
+                latitude: z.number().optional().describe('위도 (선택)'),
+                longitude: z.number().optional().describe('경도 (선택)'),
+                storeKeyword: z.string().optional().describe('매장 키워드 필터 (예: 강남)'),
+                area1: z.string().optional().describe('시/도 (예: 서울특별시)'),
+                area2: z.string().optional().describe('구/군 (예: 강남구)'),
+                service24h: z.boolean().optional().default(false).describe('24시간 매장만 대상으로 조회'),
+                productPage: z.number().optional().default(1).describe('상품 검색 페이지 (기본값: 1)'),
+                productPageSize: z.number().optional().default(10).describe('상품 검색 수 (기본값: 10)'),
+                storeLimit: z.number().optional().default(10).describe('조회할 매장 수 (기본값: 10)'),
+                timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
+            },
+        },
+        handler: checkInventory,
+    };
+}