daiso 1.0.6 → 1.0.8

package/dist/services/compare/client.js

@@ -0,0 +1,133 @@
+import { fetchProducts as fetchDaisoProducts } from '../daiso/tools/searchProducts.js';
+import { fetchGs25SearchProducts } from '../gs25/client.js';
+import { searchSevenElevenProducts } from '../seveneleven/client.js';
+import { searchEmart24Products } from '../emart24/client.js';
+const DEFAULT_COMPARE_SERVICES = ['daiso', 'gs25', 'seveneleven', 'emart24'];
+const SERVICE_NAMES = {
+    daiso: '다이소',
+    gs25: 'GS25',
+    seveneleven: '세븐일레븐',
+    emart24: '이마트24',
+};
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function parseServices(value) {
+    if (!value || value.trim().length === 0) {
+        return DEFAULT_COMPARE_SERVICES;
+    }
+    const allowed = new Set(DEFAULT_COMPARE_SERVICES);
+    const services = value
+        .split(',')
+        .map((item) => item.trim().toLowerCase())
+        .filter((item) => allowed.has(item));
+    return services.length > 0 ? [...new Set(services)] : DEFAULT_COMPARE_SERVICES;
+}
+function normalizePrice(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : null;
+}
+function sortComparableProducts(products) {
+    const serviceOrder = new Map(DEFAULT_COMPARE_SERVICES.map((service, index) => [service, index]));
+    return [...products].sort((a, b) => {
+        if (a.price !== null && b.price !== null && a.price !== b.price) {
+            return a.price - b.price;
+        }
+        if (a.price !== null && b.price === null) {
+            return -1;
+        }
+        if (a.price === null && b.price !== null) {
+            return 1;
+        }
+        return serviceOrder.get(a.service) - serviceOrder.get(b.service);
+    });
+}
+async function searchService(service, keyword, limit) {
+    if (service === 'daiso') {
+        const result = await fetchDaisoProducts(keyword, 1, limit);
+        return result.products.map((product) => ({
+            service,
+            serviceName: SERVICE_NAMES[service],
+            code: product.id,
+            name: product.name,
+            price: normalizePrice(product.price),
+            imageUrl: product.imageUrl,
+            raw: product,
+        }));
+    }
+    if (service === 'gs25') {
+        const products = await fetchGs25SearchProducts(keyword, { timeout: 15000 });
+        return products.slice(0, limit).map((product) => ({
+            service,
+            serviceName: SERVICE_NAMES[service],
+            code: product.itemCode,
+            name: product.itemName || product.shortItemName,
+            price: null,
+            imageUrl: product.imageUrl,
+            stockCheckEnabled: product.stockCheckEnabled,
+            raw: product,
+        }));
+    }
+    if (service === 'seveneleven') {
+        const result = await searchSevenElevenProducts({ query: keyword, page: 1, size: limit });
+        return result.products.map((product) => ({
+            service,
+            serviceName: SERVICE_NAMES[service],
+            code: product.itemCode || product.productNo,
+            name: product.itemName,
+            price: normalizePrice(product.salePrice),
+            originalPrice: normalizePrice(product.originalPrice),
+            imageUrl: product.imageUrl,
+            raw: product,
+        }));
+    }
+    const result = await searchEmart24Products({
+        keyword,
+        page: 1,
+        pageSize: limit,
+        sortType: 'PRICE_ASC',
+        saleProductYn: 'N',
+    });
+    return result.products.map((product) => ({
+        service,
+        serviceName: SERVICE_NAMES[service],
+        code: product.pluCd,
+        name: product.goodsName,
+        price: normalizePrice(product.viewPrice),
+        originalPrice: normalizePrice(product.originPrice),
+        raw: product,
+    }));
+}
+export function parseCompareServices(value) {
+    return parseServices(value);
+}
+export async function compareProducts(params) {
+    const keyword = params.keyword.trim();
+    const limit = Math.max(1, Math.min(Math.trunc(params.limit || 5), 20));
+    const services = params.services && params.services.length > 0 ? params.services : DEFAULT_COMPARE_SERVICES;
+    const settled = await Promise.allSettled(services.map(async (service) => ({
+        service,
+        products: await searchService(service, keyword, limit),
+    })));
+    const results = [];
+    const errors = [];
+    for (const item of settled) {
+        if (item.status === 'fulfilled') {
+            results.push(...item.value.products);
+        }
+        else {
+            const service = services[settled.indexOf(item)];
+            errors.push({ service, message: toErrorMessage(item.reason) });
+        }
+    }
+    const sorted = sortComparableProducts(results);
+    return {
+        keyword,
+        services,
+        serviceCount: services.length,
+        resultCount: sorted.length,
+        bestPrice: sorted.find((product) => product.price !== null) || null,
+        results: sorted,
+        errors,
+        note: '새 외부 키 없이 기존 공개 상품 검색을 묶은 가격 후보입니다. 실제 재고와 행사가는 매장별로 달라질 수 있습니다.',
+    };
+}

package/dist/services/compare/index.js

@@ -0,0 +1,17 @@
+import { createCompareProductsTool } from './tools/compareProducts.js';
+const COMPARE_METADATA = {
+    id: 'compare',
+    name: '통합 비교',
+    version: '1.0.0',
+    description: '새 외부 키 없이 기존 상품 검색을 묶어 가격 후보를 비교하는 서비스',
+};
+class CompareService {
+    metadata = COMPARE_METADATA;
+    getTools() {
+        return [createCompareProductsTool()];
+    }
+}
+export function createCompareService() {
+    return new CompareService();
+}
+export * from './types.js';

package/dist/services/compare/tools/compareProducts.js

@@ -0,0 +1,45 @@
+import * as z from 'zod';
+import { compareProducts, parseCompareServices } from '../client.js';
+async function compareProductsHandler(args) {
+    const keyword = args.keyword?.trim();
+    if (!keyword) {
+        throw new Error('검색어(keyword)를 입력해주세요.');
+    }
+    const result = await compareProducts({
+        keyword,
+        limit: args.limit,
+        services: parseCompareServices(args.services),
+    });
+    return {
+        content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        structuredContent: { ...result },
+    };
+}
+export function createCompareProductsTool() {
+    return {
+        name: 'compare_products',
+        metadata: {
+            title: '가격 후보 통합 비교',
+            description: '새 외부 키 없이 다이소, GS25, 세븐일레븐, 이마트24 상품 검색을 묶어 가격 후보를 비교합니다.',
+            inputSchema: {
+                keyword: z.string().describe('비교할 상품 검색어'),
+                limit: z.number().optional().default(5).describe('서비스별 최대 결과 수'),
+                services: z
+                    .string()
+                    .optional()
+                    .describe('쉼표로 구분한 서비스 목록(daiso,gs25,seveneleven,emart24)'),
+            },
+            outputSchema: {
+                keyword: z.string().optional(),
+                services: z.array(z.string()).optional(),
+                serviceCount: z.number().optional(),
+                resultCount: z.number().optional(),
+                bestPrice: z.unknown().optional(),
+                results: z.array(z.unknown()).optional(),
+                errors: z.array(z.unknown()).optional(),
+                note: z.string().optional(),
+            },
+        },
+        handler: compareProductsHandler,
+    };
+}

package/dist/services/compare/types.js

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

package/dist/services/gs25/api.js

@@ -6,4 +6,7 @@ export const GS25_API = {
     STORE_STOCK_PATH: '/api/bff/v2/store/stock',
     APIGW_BASE_URL: 'https://b2c-apigw.woodongs.com',
     TOTAL_SEARCH_PATH: '/search/v3/totalSearch',
+    WEB_BASE_URL: 'https://gs25.gsretail.com',
+    WEB_LOCATIONS_PATH: '/gscvs/ko/store-services/locations',
+    WEB_LOCATION_LIST_PATH: '/gscvs/ko/store-services/locationList',
 };

package/dist/services/gs25/client.js

@@ -2,12 +2,21 @@
  * GS25 API 클라이언트
  */
 /* c8 ignore start */
-import { fetchJson } from '../../utils/http.js';
+import { fetchJson, fetchWithTimeout, HttpError } from '../../utils/http.js';
+import { decodeZyteHttpBody, requestByZyte } from '../../utils/zyte.js';
 import { GS25_API } from './api.js';
 import { normalizeStore, toNumber } from './storeUtils.js';
 export { attachDistanceToGs25Stores, calculateDistanceM, extractGs25ProductCandidates, filterGs25StoresByKeyword, selectGs25StoresForKeyword, sortGs25Stores, } from './storeUtils.js';
 const GS25_DEFAULT_HEADERS = {
     Accept: 'application/json, text/plain, */*',
+    'Accept-Language': 'ko-KR,ko;q=0.9,en-US;q=0.8,en;q=0.7',
+    'User-Agent': 'Mozilla/5.0 (Linux; Android 15; SM-S928N) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/124.0 Mobile Safari/537.36',
+    Origin: 'https://woodongs.com',
+    Referer: 'https://woodongs.com/',
+};
+const GS25_TOTAL_SEARCH_HEADERS = {
+    ...GS25_DEFAULT_HEADERS,
+    'Content-Type': 'application/json',
 };
 const GS25_DEFAULT_FETCH_OPTIONS = {
     retries: 1,
@@ -15,6 +24,107 @@ const GS25_DEFAULT_FETCH_OPTIONS = {
 };
 const GS25_STORES_CACHE_TTL_MS = 60 * 5 * 1000;
 const gs25StoresCache = new Map();
+function extractGs25WebCsrfToken(html) {
+    return (html.match(/name="CSRFToken"\s+value="([^"]+)"/)?.[1] ||
+        html.match(/ACC\.config\.CSRFToken\s*=\s*"([^"]+)"/)?.[1] ||
+        null);
+}
+function extractGs25WebCookieHeader(headers) {
+    const setCookie = headers.get('set-cookie') || '';
+    const jsessionId = setCookie.match(/JSESSIONID=[^;,\s]+/)?.[0];
+    return jsessionId;
+}
+function parseGs25WebLocationResponse(body) {
+    if (typeof body === 'string') {
+        return JSON.parse(body);
+    }
+    return body;
+}
+function normalizeGs25WebStore(raw) {
+    const propertyNames = (raw.offeringService || []).filter((item) => item.trim().length > 0);
+    return {
+        storeCode: raw.shopCode || '',
+        storeName: raw.shopName || '',
+        address: raw.address || '',
+        phone: '',
+        latitude: toNumber(raw.longs),
+        longitude: toNumber(raw.lat),
+        serviceCode: '01',
+        realStockQuantity: 0,
+        pickupStockQuantity: 0,
+        deliveryStockQuantity: 0,
+        isSoldOut: false,
+        searchItemName: '',
+        searchItemSellPrice: null,
+        propertyNames,
+        properties: propertyNames.map((name) => ({
+            code: name,
+            name,
+            type: 'service',
+            imageUrl: '',
+        })),
+        distanceM: null,
+    };
+}
+async function fetchGs25StoreStock(url, options) {
+    try {
+        return await fetchJson(url, {
+            ...GS25_DEFAULT_FETCH_OPTIONS,
+            method: 'GET',
+            timeout: options.timeout,
+            headers: GS25_DEFAULT_HEADERS,
+        });
+    }
+    catch (error) {
+        const zyteApiKey = options.zyteApiKey?.trim();
+        if (!(error instanceof HttpError) || error.status !== 403 || !zyteApiKey) {
+            throw error;
+        }
+        const result = await requestByZyte({
+            apiKey: zyteApiKey,
+            url,
+            method: 'GET',
+            timeout: options.timeout,
+            retries: 1,
+            headers: Object.entries(GS25_DEFAULT_HEADERS).map(([name, value]) => ({ name, value })),
+        });
+        return decodeZyteHttpBody(result);
+    }
+}
+async function fetchGs25TotalSearchResponse(query, options) {
+    const { timeout = 20000 } = options;
+    const endpoint = new URL(GS25_API.TOTAL_SEARCH_PATH, GS25_API.APIGW_BASE_URL);
+    const bodyText = JSON.stringify({ query });
+    try {
+        return await fetchJson(endpoint.toString(), {
+            ...GS25_DEFAULT_FETCH_OPTIONS,
+            method: 'POST',
+            retryUnsafeMethods: true,
+            timeout,
+            headers: GS25_TOTAL_SEARCH_HEADERS,
+            body: bodyText,
+        });
+    }
+    catch (error) {
+        const zyteApiKey = options.zyteApiKey?.trim();
+        if (!(error instanceof HttpError) || error.status !== 403 || !zyteApiKey) {
+            throw error;
+        }
+        const result = await requestByZyte({
+            apiKey: zyteApiKey,
+            url: endpoint.toString(),
+            method: 'POST',
+            timeout,
+            retries: 1,
+            headers: Object.entries(GS25_TOTAL_SEARCH_HEADERS).map(([name, value]) => ({
+                name,
+                value,
+            })),
+            bodyText,
+        });
+        return decodeZyteHttpBody(result);
+    }
+}
 function buildCacheKey(params) {
     return [
         params.serviceCode,
@@ -59,8 +169,94 @@ export async function geocodeGs25Address(address, options = {}) {
     }
     return { latitude, longitude };
 }
+export async function fetchGs25WebStores(keyword, options = {}) {
+    const query = keyword.trim();
+    if (query.length === 0) {
+        return { totalCount: 0, stores: [] };
+    }
+    const { timeout = 20000 } = options;
+    const locationsUrl = new URL(GS25_API.WEB_LOCATIONS_PATH, GS25_API.WEB_BASE_URL);
+    const locationsResponse = await fetchWithTimeout(locationsUrl.toString(), {
+        ...GS25_DEFAULT_FETCH_OPTIONS,
+        method: 'GET',
+        timeout,
+        headers: {
+            Accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+            'Accept-Language': GS25_DEFAULT_HEADERS['Accept-Language'],
+            'User-Agent': GS25_DEFAULT_HEADERS['User-Agent'],
+        },
+    });
+    if (!locationsResponse.ok) {
+        throw new HttpError(locationsResponse.status, locationsResponse.statusText, await locationsResponse.text());
+    }
+    const html = await locationsResponse.text();
+    const csrfToken = extractGs25WebCsrfToken(html);
+    if (!csrfToken) {
+        throw new Error('GS25 웹 매장 검색 CSRF 토큰을 찾을 수 없습니다.');
+    }
+    const form = new URLSearchParams({
+        pageNum: '1',
+        pageSize: '50',
+        searchShopName: query,
+        searchSido: '',
+        searchGugun: '',
+        searchDong: '',
+        searchType: '',
+        searchTypeService: '0',
+        searchTypeToto: '0',
+        searchTypeCafe25: '0',
+        searchTypeInstant: '0',
+        searchTypeDrug: '0',
+        searchTypeSelf25: '0',
+        searchTypePost: '0',
+        searchTypeATM: '0',
+        searchTypeWithdrawal: '0',
+        searchTypeTaxrefund: '0',
+        searchTypeSmartAtm: '0',
+        searchTypeSelfCookingUtensils: '0',
+        searchTypeDeliveryService: '0',
+        searchTypeParcelService: '0',
+        searchTypePotatoes: '0',
+        searchTypeCardiacDefi: '0',
+        searchTypeFishShapedBun: '0',
+        searchTypeWine25: '0',
+        searchTypeGoPizza: '0',
+        searchTypeSpiritWine: '0',
+        searchTypeFreshGanghw: '0',
+        searchTypeMusinsa: '0',
+        searchTypePosa: '0',
+    });
+    const locationListUrl = new URL(GS25_API.WEB_LOCATION_LIST_PATH, GS25_API.WEB_BASE_URL);
+    locationListUrl.searchParams.set('CSRFToken', csrfToken);
+    const cookieHeader = extractGs25WebCookieHeader(locationsResponse.headers);
+    const body = parseGs25WebLocationResponse(await fetchJson(locationListUrl.toString(), {
+        ...GS25_DEFAULT_FETCH_OPTIONS,
+        method: 'POST',
+        retryUnsafeMethods: true,
+        timeout,
+        headers: {
+            Accept: 'application/json, text/javascript, */*; q=0.01',
+            'Accept-Language': GS25_DEFAULT_HEADERS['Accept-Language'],
+            'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+            Referer: locationsUrl.toString(),
+            'User-Agent': GS25_DEFAULT_HEADERS['User-Agent'],
+            'X-Requested-With': 'XMLHttpRequest',
+            ...(cookieHeader ? { Cookie: cookieHeader } : {}),
+        },
+        body: form.toString(),
+    }));
+    const stores = (body.results || [])
+        .map(normalizeGs25WebStore)
+        .filter((store) => store.storeCode.length > 0);
+    return {
+        totalCount: typeof body.pagination?.totalNumberOfResults === 'number'
+            ? body.pagination.totalNumberOfResults
+            : stores.length,
+        stores,
+    };
+}
 export async function fetchGs25Stores(params = {}, options = {}) {
-    const { serviceCode = '01', keyword = '', itemCode = '', storeCode = '', realTimeStockYn = 'Y', latitude, longitude, pageNumber = 0, pageCount = 20000, useCache = true, } = params;
+    const { serviceCode = '01', keyword = '', itemCode = '', storeCode = '', realTimeStockYn = 'Y', latitude, longitude, pageNumber, pageCount, useCache = true, } = params;
     const { timeout = 20000 } = options;
     const cacheKey = buildCacheKey({
         serviceCode,
@@ -82,9 +278,13 @@ export async function fetchGs25Stores(params = {}, options = {}) {
     }
     const endpoint = new URL(GS25_API.STORE_STOCK_PATH, GS25_API.BFF_BASE_URL);
     endpoint.searchParams.set('serviceCode', serviceCode);
-    endpoint.searchParams.set('pageNumber', String(pageNumber));
-    endpoint.searchParams.set('pageCount', String(pageCount));
     endpoint.searchParams.set('realTimeStockYn', realTimeStockYn);
+    if (typeof pageNumber === 'number' && Number.isFinite(pageNumber)) {
+        endpoint.searchParams.set('pageNumber', String(Math.trunc(pageNumber)));
+    }
+    if (typeof pageCount === 'number' && Number.isFinite(pageCount)) {
+        endpoint.searchParams.set('pageCount', String(Math.trunc(pageCount)));
+    }
     // itemCode가 있으면 itemCode 사용, 없으면 keyword 사용
     // 주의: itemCode 사용 시 좌표도 필수
     if (itemCode.trim().length > 0) {
@@ -113,13 +313,13 @@ export async function fetchGs25Stores(params = {}, options = {}) {
         endpoint.searchParams.set('isSuperDlvyStoreSelected', 'N');
         endpoint.searchParams.set('isGs25DlvyStoreSelected', 'N');
     }
-    const body = await fetchJson(endpoint.toString(), {
-        ...GS25_DEFAULT_FETCH_OPTIONS,
-        method: 'GET',
+    const body = await fetchGs25StoreStock(endpoint.toString(), {
         timeout,
-        headers: GS25_DEFAULT_HEADERS,
+        zyteApiKey: options.zyteApiKey,
     });
-    const stores = (body.stores || []).map(normalizeStore).filter((store) => store.storeCode.length > 0);
+    const stores = (body.stores || [])
+        .map(normalizeStore)
+        .filter((store) => store.storeCode.length > 0);
     if (useCache) {
         gs25StoresCache.set(cacheKey, {
             stores,
@@ -137,19 +337,7 @@ export async function fetchGs25NormalizedKeyword(keyword, options = {}) {
     if (query.length === 0) {
         return null;
     }
-    const { timeout = 20000 } = options;
-    const endpoint = new URL(GS25_API.TOTAL_SEARCH_PATH, GS25_API.APIGW_BASE_URL);
-    const body = await fetchJson(endpoint.toString(), {
-        ...GS25_DEFAULT_FETCH_OPTIONS,
-        method: 'POST',
-        retryUnsafeMethods: true,
-        timeout,
-        headers: {
-            Accept: 'application/json, text/plain, */*',
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ query }),
-    });
+    const body = await fetchGs25TotalSearchResponse(query, options);
     const normalizedKeyword = body.SearchQueryResult?.keywordInfo?.keyword?.trim() || '';
     const normalizedSearchKeyword = body.SearchQueryResult?.keywordInfo?.searchKeyword?.trim() || '';
     if (normalizedKeyword.length === 0 && normalizedSearchKeyword.length === 0) {
@@ -169,19 +357,7 @@ export async function fetchGs25SearchProducts(keyword, options = {}) {
     if (query.length === 0) {
         return [];
     }
-    const { timeout = 20000 } = options;
-    const endpoint = new URL(GS25_API.TOTAL_SEARCH_PATH, GS25_API.APIGW_BASE_URL);
-    const body = await fetchJson(endpoint.toString(), {
-        ...GS25_DEFAULT_FETCH_OPTIONS,
-        method: 'POST',
-        retryUnsafeMethods: true,
-        timeout,
-        headers: {
-            Accept: 'application/json, text/plain, */*',
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ query }),
-    });
+    const body = await fetchGs25TotalSearchResponse(query, options);
     const products = [];
     const collections = body.SearchQueryResult?.Collection || [];
     for (const collection of collections) {

package/dist/services/gs25/index.js

@@ -11,12 +11,20 @@ const GS25_METADATA = {
     description: 'GS25 매장 탐색, 상품 키워드 검색, 재고 조회 서비스',
 };
 class Gs25Service {
+    options;
     metadata = GS25_METADATA;
+    constructor(options = {}) {
+        this.options = options;
+    }
     getTools() {
-        return [createFindNearbyStoresTool(), createSearchProductsTool(), createCheckInventoryTool()];
+        return [
+            createFindNearbyStoresTool(this.options.googleMapsApiKey, this.options.zyteApiKey),
+            createSearchProductsTool(this.options.zyteApiKey),
+            createCheckInventoryTool(this.options.googleMapsApiKey, this.options.zyteApiKey),
+        ];
     }
 }
-export function createGs25Service() {
-    return new Gs25Service();
+export function createGs25Service(options = {}) {
+    return new Gs25Service(options);
 }
 export * from './types.js';

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

@@ -4,8 +4,11 @@
 /* c8 ignore start */
 import * as z from 'zod';
 import { attachDistanceToGs25Stores, fetchGs25SearchProducts, fetchGs25Stores, filterGs25StoresByKeyword, geocodeGs25Address, selectGs25StoresForKeyword, sortGs25Stores, } from '../client.js';
+function getProcessEnvValue(name) {
+    return typeof process !== 'undefined' ? process.env[name] : undefined;
+}
 async function checkInventory(args) {
-    const { keyword, itemCode: providedItemCode, latitude, longitude, storeKeyword = '', serviceCode = '01', storeLimit = 20, timeoutMs = 20000, } = args;
+    const { keyword, itemCode: providedItemCode, latitude, longitude, storeKeyword = '', serviceCode = '01', storeLimit = 20, timeoutMs = 20000, googleMapsApiKey = getProcessEnvValue('GOOGLE_MAPS_API_KEY'), zyteApiKey = getProcessEnvValue('ZYTE_API_KEY'), } = args;
     if (!keyword || keyword.trim().length === 0) {
         throw new Error('상품 검색어(keyword)를 입력해주세요.');
     }
@@ -21,13 +24,13 @@ async function checkInventory(args) {
             serviceCode,
         }, {
             timeout: timeoutMs,
+            zyteApiKey,
         });
-        const firstAddress = filterGs25StoresByKeyword(baseStores.stores, storeKeyword).find((store) => store.address.trim().length > 0)
-            ?.address || '';
+        const firstAddress = filterGs25StoresByKeyword(baseStores.stores, storeKeyword).find((store) => store.address.trim().length > 0)?.address || '';
         if (firstAddress.length > 0) {
             const geocoded = await geocodeGs25Address(firstAddress, {
                 timeout: timeoutMs,
-                googleMapsApiKey: process.env.GOOGLE_MAPS_API_KEY,
+                googleMapsApiKey,
             });
             if (geocoded) {
                 resolvedLatitude = geocoded.latitude;
@@ -57,11 +60,15 @@ async function checkInventory(args) {
             useCache: false,
         }, {
             timeout: timeoutMs,
+            zyteApiKey,
         });
     }
     else {
         // itemCode가 없으면 totalSearch API로 키워드 → itemCode 변환
-        const searchProducts = await fetchGs25SearchProducts(keyword, { timeout: timeoutMs });
+        const searchProducts = await fetchGs25SearchProducts(keyword, {
+            timeout: timeoutMs,
+            zyteApiKey,
+        });
         firstProduct = searchProducts.find((p) => p.itemCode.length > 0);
         if (firstProduct) {
             resolvedItemCode = firstProduct.itemCode;
@@ -75,6 +82,7 @@ async function checkInventory(args) {
                 useCache: false,
             }, {
                 timeout: timeoutMs,
+                zyteApiKey,
             });
         }
         else {
@@ -88,6 +96,7 @@ async function checkInventory(args) {
                 useCache: false,
             }, {
                 timeout: timeoutMs,
+                zyteApiKey,
             });
         }
     }
@@ -101,7 +110,8 @@ async function checkInventory(args) {
     const totalStockQuantity = filteredByStoreKeyword.reduce((sum, item) => sum + Math.max(item.realStockQuantity, 0), 0);
     // searchProducts에서 상품 정보 사용
     const firstProductName = firstProduct?.itemName || firstProduct?.shortItemName || null;
-    const firstProductPrice = filteredByStoreKeyword.find((item) => item.searchItemSellPrice !== null)?.searchItemSellPrice ?? null;
+    const firstProductPrice = filteredByStoreKeyword.find((item) => item.searchItemSellPrice !== null)?.searchItemSellPrice ??
+        null;
     return {
         content: [
             {
@@ -137,7 +147,7 @@ async function checkInventory(args) {
         ],
     };
 }
-export function createCheckInventoryTool() {
+export function createCheckInventoryTool(googleMapsApiKey, zyteApiKey) {
     return {
         name: 'gs25_check_inventory',
         metadata: {
@@ -149,15 +159,32 @@ export function createCheckInventoryTool() {
                     .string()
                     .optional()
                     .describe('상품 코드 (gs25_search_products로 조회한 정확한 코드, 제공 시 keyword 검색 건너뜀)'),
-                latitude: z.number().optional().describe('위도 (선택, 미입력 시 storeKeyword 지오코딩 시도)'),
-                longitude: z.number().optional().describe('경도 (선택, 미입력 시 storeKeyword 지오코딩 시도)'),
-                storeKeyword: z.string().optional().describe('매장명/주소 키워드 필터 (예: 강남, 안산 중앙역)'),
+                latitude: z
+                    .number()
+                    .optional()
+                    .describe('위도 (선택, 미입력 시 storeKeyword 지오코딩 시도)'),
+                longitude: z
+                    .number()
+                    .optional()
+                    .describe('경도 (선택, 미입력 시 storeKeyword 지오코딩 시도)'),
+                storeKeyword: z
+                    .string()
+                    .optional()
+                    .describe('매장명/주소 키워드 필터 (예: 강남, 안산 중앙역)'),
                 serviceCode: z.string().optional().default('01').describe('서비스 코드 (기본값: 01=GS25)'),
                 storeLimit: 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: checkInventory,
+        handler: ((args) => checkInventory({
+            ...args,
+            googleMapsApiKey: args.googleMapsApiKey || googleMapsApiKey,
+            zyteApiKey: args.zyteApiKey || zyteApiKey,
+        })),
     };
 }
 /* c8 ignore stop */