daiso 1.0.7 → 1.0.9

package/dist/pages/promptReferenceText.js

@@ -58,6 +58,20 @@ export function buildPromptReferenceText(baseUrl) {
 | LOTTEMART_PRODUCT_SEARCH_FAILED | 롯데마트 상품 조회 실패 |
 | SEVENELEVEN_INVENTORY_CHECK_FAILED | 세븐일레븐 재고 조회 실패 |
 | PLACES_SEARCH_FAILED | 주변 장소 검색 실패 |
+| DEVELOPER_REQUEST_SUBMIT_FAILED | 개발자 요청 저장 실패 |
+
+---
+
+## 에이전트 실행 레시피
+
+- "콜라 어디가 싸?", "컵라면 가격 비교해줘": 먼저 \`compare_products\` 또는 /api/compare/products를 호출합니다. 실제 재고와 매장 행사가가 필요하면 최저가 후보의 서비스별 재고/상품 도구로 한 번 더 확인합니다.
+- "강남역 근처 카페", "성수동 브런치 음식점": 브랜드를 되묻지 말고 \`places_search_nearby\` 또는 /api/places/search를 호출합니다. 이 검색은 키워드 기반이므로 좌표 반경 결과처럼 단정하지 않습니다.
+- "다이소 핫식스 재고", "올리브영 두바이초콜릿 있어?": 상품이 브랜드와 어색해 보여도 브랜드를 바꾸지 말고 먼저 다이소로 검색하거나 명시된 서비스로 검색합니다. 결과가 없을 때만 다른 서비스 대안을 제안합니다.
+- "GS25 강남 오감자 재고": 상품명과 위치를 분리해 상품 후보를 먼저 찾고, 선택한 itemCode나 keyword와 storeKeyword로 재고를 확인합니다.
+- "오늘 강남 CGV 시간표": 오늘 날짜는 KST 기준 YYYYMMDD로 계산하고, theaterCode가 없으면 극장 검색 후 시간표를 조회합니다.
+- MCP 기능이 제대로 동작하지 않거나 개선/신규 기능 요청이 있으면 \`submit_developer_request\` 또는 /api/feedback/requests를 사용해 개발자에게 전달합니다. 제목과 설명은 필수입니다.
+- 도구 호출이 실패하면 같은 도구를 한 번 더 좁은 조건으로 재시도합니다. 두 번 실패하면 실패한 서비스와 요청 조건을 밝히고 추측으로 결과를 만들지 않습니다.
+- 결과에 imageUrl이 있으면 각 항목 이미지 표시를 우선합니다. 쿼리 문자열이 있는 이미지 URL도 그대로 사용합니다.
 
 ---
 
@@ -98,7 +112,8 @@ export function buildPromptReferenceText(baseUrl) {
 11. **이마트24 재고 조회**: /api/emart24/inventory는 pluCd + storeKeyword 조합도 지원하므로, 상품 선택 뒤 매장 코드를 다시 모으지 않아도 됩니다.
 12. **올리브영 재고 해석**: inventory.products[].storeInventory.stores[]가 있으면 그 매장별 stockLabel과 remainQuantity를 우선 사용하고, inStock는 그 주변 매장 기준 결과로 해석합니다.
 13. **올리브영 상품 이미지 표시**: /api/oliveyoung/products 또는 oliveyoung_search_products 결과에 imageUrl이 있으면 목록형 답변에서도 각 상품 이미지를 생략하지 말고 모두 렌더링합니다. 특히 \`?l=ko\` 같은 query string을 삭제하지 말고 전체 URL 그대로 마크다운 이미지 src에 넣습니다.
-14. **주변 음식점/카페 검색**: 음식점이나 카페만 물으면 \`places_search_nearby\` 또는 /api/places/search를 먼저 사용합니다. 이 기능은 네이버 지역 검색 기반 키워드 검색이므로 좌표 반경 검색처럼 단정하지 말고, \`searchMode: "keyword"\`임을 필요할 때 짧게 밝혀주세요.
+14. **통합 가격 후보 비교**: 사용자가 브랜드를 특정하지 않고 "어디가 싸?", "비교해줘"처럼 물으면 \`compare_products\` 또는 /api/compare/products를 먼저 사용합니다. 새 외부 키 없이 기존 상품 검색을 묶은 1차 가격 후보이므로 실제 재고/행사가는 각 서비스 상세 조회로 확인해야 합니다.
+15. **주변 음식점/카페 검색**: 음식점이나 카페만 물으면 \`places_search_nearby\` 또는 /api/places/search를 먼저 사용합니다. 이 기능은 네이버 지역 검색 기반 키워드 검색이므로 좌표 반경 검색처럼 단정하지 말고, \`searchMode: "keyword"\`임을 필요할 때 짧게 밝혀주세요.
 
 ---
 
@@ -123,6 +138,8 @@ MCP 연결 정보: ${baseUrl}/mcp
 - seveneleven_check_inventory: 세븐일레븐 재고 조회
 - seveneleven_get_search_popwords: 세븐일레븐 인기 검색어 조회
 - seveneleven_get_catalog_snapshot: 세븐일레븐 카탈로그 조회
+- compare_products: 키 없는 통합 상품 가격 후보 비교
+- submit_developer_request: MCP 오류, 개선 요청, 신규 기능 요청을 개발자에게 전달
 - places_search_nearby: 음식점/카페 등 주변 장소 검색
 - oliveyoung_search_products: 올리브영 상품 검색
 - oliveyoung_find_nearby_stores: 올리브영 주변 매장 탐색

package/dist/pages/promptRetailCinemaText.js

@@ -2,7 +2,24 @@
  * 프롬프트 리테일/영화 API 섹션
  */
 export function buildPromptRetailCinemaText(baseUrl) {
-    return `### 6-0. 주변 음식점/카페 검색
+    return `### 6-0. 키 없는 통합 상품 가격 후보 비교
+
+**설명**: 새 외부 API 키 없이 기존 다이소, GS25, 세븐일레븐, 이마트24 상품 검색을 묶어 가격 후보를 비교합니다. 실제 매장 재고와 행사가까지 확정하는 기능이 아니라 "어디가 싸 보이는지"를 빠르게 고르는 1차 검색입니다.
+
+**URL**:
+- ${baseUrl}/api/compare/products?keyword={검색어}
+
+**선택 파라미터**:
+- services: daiso,gs25,seveneleven,emart24 중 쉼표 구분 목록
+- limit: 서비스별 최대 결과 수 (기본값: 5)
+
+**예시**:
+- ${baseUrl}/api/compare/products?keyword=콜라&limit=3
+- ${baseUrl}/api/compare/products?keyword=컵라면&services=seveneleven,emart24
+
+---
+
+### 6-1. 주변 음식점/카페 검색
 
 **설명**: 네이버 지역 검색으로 특정 지역의 음식점, 카페, 디저트 가게 등 주변 장소를 조회합니다. 좌표 반경 검색이 아니라 \`강남역 카페\` 같은 키워드 기반 검색입니다.
 
@@ -23,7 +40,7 @@ export function buildPromptRetailCinemaText(baseUrl) {
 
 ---
 
-### 6-1. 롯데마트 매장/상품 조회
+### 6-2. 롯데마트 매장/상품 조회
 
 **설명**: 롯데마트 계열 매장 검색과 특정 매장 기준 상품 가격/재고 조회를 제공합니다.
 
@@ -49,7 +66,7 @@ export function buildPromptRetailCinemaText(baseUrl) {
 
 ---
 
-### 6-2. GS25 매장/상품/재고 조회
+### 6-3. GS25 매장/상품/재고 조회
 
 **설명**: GS25 매장 탐색, 상품 키워드 검색, 재고 조회를 제공합니다.
 
@@ -73,7 +90,7 @@ export function buildPromptRetailCinemaText(baseUrl) {
 
 ---
 
-### 6-3. 세븐일레븐 상품/매장/재고/인기검색어/카탈로그 조회
+### 6-4. 세븐일레븐 상품/매장/재고/인기검색어/카탈로그 조회
 
 **설명**: 세븐일레븐 상품 검색, 매장 검색, 재고 수량 조회, 인기 검색어, 카탈로그 스냅샷을 제공합니다.
 

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/feedback/client.js

@@ -0,0 +1,109 @@
+import { DEVELOPER_REQUEST_SEVERITIES, DEVELOPER_REQUEST_SOURCES, DEVELOPER_REQUEST_TYPES, } from './types.js';
+function isOneOf(value, allowed) {
+    return Boolean(value && allowed.includes(value));
+}
+function trimText(value, maxLength) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return trimmed.length > maxLength ? trimmed.slice(0, maxLength) : trimmed;
+}
+function requireText(value, fieldName, maxLength) {
+    const text = trimText(value, maxLength);
+    if (!text) {
+        throw new Error(`${fieldName}를 입력해주세요.`);
+    }
+    return text;
+}
+function normalizeType(value) {
+    return isOneOf(value, DEVELOPER_REQUEST_TYPES) ? value : 'other';
+}
+function normalizeSeverity(value) {
+    return isOneOf(value, DEVELOPER_REQUEST_SEVERITIES) ? value : 'medium';
+}
+function normalizeSource(value) {
+    return isOneOf(value, DEVELOPER_REQUEST_SOURCES) ? value : undefined;
+}
+function createInsertRow(input) {
+    const row = {
+        type: normalizeType(trimText(input.type, 40)),
+        severity: normalizeSeverity(trimText(input.severity, 40)),
+        title: requireText(input.title, 'title', 160),
+        description: requireText(input.description, 'description', 4000),
+        status: 'open',
+    };
+    const service = trimText(input.service, 80);
+    const toolName = trimText(input.toolName, 120);
+    const reproduction = trimText(input.reproduction, 4000);
+    const expected = trimText(input.expected, 2000);
+    const actual = trimText(input.actual, 2000);
+    const source = normalizeSource(trimText(input.source, 40));
+    if (service)
+        row.service = service;
+    if (toolName)
+        row.tool_name = toolName;
+    if (reproduction)
+        row.reproduction = reproduction;
+    if (expected)
+        row.expected = expected;
+    if (actual)
+        row.actual = actual;
+    if (source)
+        row.source = source;
+    if (input.userContext && typeof input.userContext === 'object') {
+        row.user_context = input.userContext;
+    }
+    return row;
+}
+function requireConfig(config) {
+    const supabaseUrl = trimText(config.supabaseUrl, 400);
+    const key = trimText(config.supabaseServiceRoleKey, 4000);
+    if (!supabaseUrl || !key) {
+        throw new Error('SUPABASE_URL과 SUPABASE_SERVICE_ROLE_KEY가 필요합니다.');
+    }
+    return { supabaseUrl: supabaseUrl.replace(/\/+$/, ''), key };
+}
+function stringOrUndefined(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function resultFromRow(row, fallback) {
+    return {
+        id: stringOrUndefined(row.id) || '',
+        type: normalizeType(stringOrUndefined(row.type) || fallback.type),
+        severity: normalizeSeverity(stringOrUndefined(row.severity) || fallback.severity),
+        title: stringOrUndefined(row.title) || fallback.title,
+        service: stringOrUndefined(row.service) || fallback.service,
+        toolName: stringOrUndefined(row.tool_name) || fallback.tool_name,
+        source: normalizeSource(stringOrUndefined(row.source)) || fallback.source,
+        status: stringOrUndefined(row.status) || fallback.status,
+        createdAt: stringOrUndefined(row.created_at),
+    };
+}
+export async function submitDeveloperRequest(input, config) {
+    const { supabaseUrl, key } = requireConfig(config);
+    const row = createInsertRow(input);
+    const response = await fetch(`${supabaseUrl}/rest/v1/agent_requests`, {
+        method: 'POST',
+        headers: {
+            apikey: key,
+            Authorization: `Bearer ${key}`,
+            'Content-Type': 'application/json',
+            Prefer: 'return=representation',
+        },
+        body: JSON.stringify(row),
+    });
+    if (!response.ok) {
+        const detail = await response.text().catch(() => '');
+        throw new Error(`Supabase 저장 실패: ${response.status}${detail ? ` ${detail}` : ''}`);
+    }
+    const payload = (await response.json());
+    const returnedRow = Array.isArray(payload) ? payload[0] : payload;
+    if (!returnedRow || typeof returnedRow !== 'object') {
+        throw new Error('Supabase 저장 결과가 비어 있습니다.');
+    }
+    return resultFromRow(returnedRow, row);
+}

package/dist/services/feedback/index.js

@@ -0,0 +1,22 @@
+import { createSubmitDeveloperRequestTool } from './tools/submitDeveloperRequest.js';
+const FEEDBACK_METADATA = {
+    id: 'feedback',
+    name: '개발자 요청',
+    version: '1.0.0',
+    description: 'AI 에이전트가 MCP 오류, 개선 요청, 신규 기능 요청을 개발자에게 전달하는 서비스',
+};
+class FeedbackService {
+    config;
+    metadata = FEEDBACK_METADATA;
+    constructor(config = {}) {
+        this.config = config;
+    }
+    getTools() {
+        return [createSubmitDeveloperRequestTool(this.config)];
+    }
+}
+export function createFeedbackService(config = {}) {
+    return new FeedbackService(config);
+}
+export * from './client.js';
+export * from './types.js';

package/dist/services/feedback/tools/submitDeveloperRequest.js

@@ -0,0 +1,54 @@
+import * as z from 'zod';
+import { submitDeveloperRequest } from '../client.js';
+export function createSubmitDeveloperRequestTool(config) {
+    return {
+        name: 'submit_developer_request',
+        metadata: {
+            title: '개발자 요청 제출',
+            description: 'MCP 기능 오류, 개선 요청, 신규 기능 요청, 문서 문제를 개발자에게 전달하고 Supabase에 저장합니다.',
+            inputSchema: {
+                type: z
+                    .enum(['bug', 'improvement', 'feature', 'docs', 'other'])
+                    .optional()
+                    .default('other')
+                    .describe('요청 유형'),
+                severity: z
+                    .enum(['low', 'medium', 'high', 'critical'])
+                    .optional()
+                    .default('medium')
+                    .describe('영향도'),
+                title: z.string().describe('짧은 제목'),
+                description: z.string().describe('요청 상세 설명'),
+                service: z.string().optional().describe('관련 서비스 ID 또는 영역'),
+                toolName: z.string().optional().describe('관련 MCP 도구 이름'),
+                reproduction: z.string().optional().describe('재현 방법'),
+                expected: z.string().optional().describe('기대 결과'),
+                actual: z.string().optional().describe('실제 결과'),
+                source: z
+                    .enum(['mcp', 'chatgpt', 'claude', 'cli', 'api', 'other'])
+                    .optional()
+                    .default('mcp')
+                    .describe('요청 출처'),
+                userContext: z.object({}).loose().optional().describe('추가 컨텍스트 JSON'),
+            },
+            outputSchema: {
+                id: z.string().optional(),
+                type: z.string().optional(),
+                severity: z.string().optional(),
+                title: z.string().optional(),
+                service: z.string().optional(),
+                toolName: z.string().optional(),
+                source: z.string().optional(),
+                status: z.string().optional(),
+                createdAt: z.string().optional(),
+            },
+        },
+        handler: (async (args) => {
+            const result = await submitDeveloperRequest(args, config);
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                structuredContent: { ...result },
+            };
+        }),
+    };
+}

package/dist/services/feedback/types.js

@@ -0,0 +1,3 @@
+export const DEVELOPER_REQUEST_TYPES = ['bug', 'improvement', 'feature', 'docs', 'other'];
+export const DEVELOPER_REQUEST_SEVERITIES = ['low', 'medium', 'high', 'critical'];
+export const DEVELOPER_REQUEST_SOURCES = ['mcp', 'chatgpt', 'claude', 'cli', 'api', 'other'];

package/dist/services/gs25/client.js

@@ -6,6 +6,7 @@ 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 { fetchGs25NormalizedKeyword, fetchGs25SearchProducts, } from './productSearch.js';
 export { attachDistanceToGs25Stores, calculateDistanceM, extractGs25ProductCandidates, filterGs25StoresByKeyword, selectGs25StoresForKeyword, sortGs25Stores, } from './storeUtils.js';
 const GS25_DEFAULT_HEADERS = {
     Accept: 'application/json, text/plain, */*',
@@ -14,10 +15,6 @@ const GS25_DEFAULT_HEADERS = {
     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,
     retryDelayMs: 250,
@@ -91,40 +88,6 @@ async function fetchGs25StoreStock(url, options) {
         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,
@@ -332,52 +295,6 @@ export async function fetchGs25Stores(params = {}, options = {}) {
         cacheHit: false,
     };
 }
-export async function fetchGs25NormalizedKeyword(keyword, options = {}) {
-    const query = keyword.trim();
-    if (query.length === 0) {
-        return null;
-    }
-    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) {
-        return null;
-    }
-    return {
-        keyword: normalizedKeyword,
-        searchKeyword: normalizedSearchKeyword,
-    };
-}
-/**
- * 키워드로 상품을 검색하여 itemCode 목록을 반환합니다.
- * 재고 조회 API는 itemCode가 필요하므로 이 함수로 먼저 변환해야 합니다.
- */
-export async function fetchGs25SearchProducts(keyword, options = {}) {
-    const query = keyword.trim();
-    if (query.length === 0) {
-        return [];
-    }
-    const body = await fetchGs25TotalSearchResponse(query, options);
-    const products = [];
-    const collections = body.SearchQueryResult?.Collection || [];
-    for (const collection of collections) {
-        const documents = collection.Documentset?.Document || [];
-        for (const doc of documents) {
-            const field = doc.field;
-            if (!field?.itemCode)
-                continue;
-            products.push({
-                itemCode: field.itemCode,
-                itemName: field.itemName || '',
-                shortItemName: field.shortItemName || '',
-                imageUrl: field.itemImageUrl || '',
-                rating: toNumber(field.starPoint),
-                stockCheckEnabled: field.stockCheckYn === 'Y',
-            });
-        }
-    }
-    return products;
-}
 export function clearGs25StoresCache() {
     gs25StoresCache.clear();
 }