daiso 1.0.10 → 1.2.0

package/dist/services/cu/client.js

@@ -2,12 +2,15 @@
  * CU API 클라이언트
  */
 import { fetchJson } from '../../utils/http.js';
-import { decodeBase64, requestByZyte } from '../../utils/zyte.js';
+import { ZYTE_COST_POLICY_MESSAGE } from '../../core/errors.js';
+import { fetchJsonWithZyteFallback } from '../../utils/zyteJsonFallback.js';
 import { CU_API } from './api.js';
+import { cuStockUnavailableReason } from './upstreamError.js';
 const CU_DEFAULT_HEADERS = {
     'Content-Type': 'application/json',
     Accept: 'application/json, text/javascript, */*; q=0.01',
     'X-Requested-With': 'XMLHttpRequest',
+    'User-Agent': 'Mozilla/5.0 (Linux; Android 12) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/138.0.0.0 Mobile Safari/537.36;BGFCU',
 };
 const CU_WEB_DEFAULT_HEADERS = {
     'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
@@ -44,44 +47,31 @@ function toStoreAddress(raw) {
     }
     return [raw.addrFst || '', raw.addrDetail || ''].join(' ').trim();
 }
-async function requestCuJson(path, body, timeout = 15000) {
-    return fetchJson(`${CU_API.BASE_URL}${path}`, {
+async function requestCuJson(path, body, options = {}) {
+    return fetchJsonWithZyteFallback(`${CU_API.BASE_URL}${path}`, {
         method: 'POST',
-        timeout,
+        timeout: options.timeout,
         headers: CU_DEFAULT_HEADERS,
         body: JSON.stringify(body),
+        zyteApiKey: options.apiKey,
+        zyteTags: { service: 'cu' },
     });
 }
-async function requestCuWebHtml(path, body, apiKey, timeout = 15000) {
+async function requestCuWebHtml(path, body, _apiKey, timeout = 15000) {
     const form = new URLSearchParams(body);
     const formText = form.toString();
     const targetUrl = `${CU_API.WEB_BASE_URL}${path}`;
-    const response = await fetch(`${CU_API.WEB_BASE_URL}${path}`, {
-        method: 'POST',
+    // 공식 웹의 GET 조회는 같은 검색 조건을 지원하며 추가 재시도 시간을 쓰지 않습니다.
+    const response = await fetch(`${targetUrl}?${formText}`, {
+        method: 'GET',
         headers: CU_WEB_DEFAULT_HEADERS,
-        body: formText,
         signal: AbortSignal.timeout(timeout),
     });
     if (response.ok) {
         return response.text();
     }
     if (response.status === 400 || response.status === 403 || response.status === 429) {
-        try {
-            const result = await requestByZyte({
-                apiKey,
-                url: targetUrl,
-                timeout,
-                method: 'POST',
-                headers: Object.entries(CU_WEB_DEFAULT_HEADERS).map(([name, value]) => ({ name, value })),
-                bodyText: formText,
-            });
-            if (result.statusCode === 200 && result.httpResponseBody) {
-                return decodeBase64(result.httpResponseBody);
-            }
-        }
-        catch {
-            // 직접 호출 실패 시 Zyte 재시도도 실패하면 원본 에러를 반환합니다.
-        }
+        throw new Error(ZYTE_COST_POLICY_MESSAGE);
     }
     throw new Error(`API 요청 실패: ${response.status} ${response.statusText}`);
 }
@@ -240,7 +230,7 @@ export async function fetchCuStores(params, options = {}) {
         item_cd: params.itemCd || '',
         onItemNo: params.onItemNo || '',
     };
-    const body = await requestCuJson(CU_API.STORE_PATH, payload, timeout);
+    const body = await requestCuJson(CU_API.STORE_PATH, payload, options);
     const stores = (body.storeList || []).map((store) => normalizeCuStore(store));
     return {
         totalCount: toNumber(body.totalCnt) || stores.length,
@@ -252,16 +242,19 @@ export async function fetchCuStores(params, options = {}) {
  * 정책 변경 시 사전 호출이 필요한 경우를 대비한 워밍업 요청입니다.
  */
 export async function primeCuStockDisplay(options = {}) {
-    const { timeout = 15000 } = options;
-    await requestCuJson(CU_API.STOCK_DISPLAY_PATH, {}, timeout);
+    await fetchJson(`${CU_API.BASE_URL}${CU_API.STOCK_DISPLAY_PATH}`, {
+        method: 'POST',
+        timeout: options.timeout,
+        headers: CU_DEFAULT_HEADERS,
+        body: '{}',
+    });
 }
 /**
  * CU 상품 재고 검색 결과를 조회합니다.
  */
 export async function fetchCuStock(params, options = {}) {
-    const { timeout = 15000 } = options;
     try {
-        await primeCuStockDisplay({ timeout });
+        await primeCuStockDisplay(options);
     }
     catch {
         // 사전 워밍업 실패는 본 검색으로 재시도합니다.
@@ -274,7 +267,26 @@ export async function fetchCuStock(params, options = {}) {
         limit: params.limit,
         searchSort: params.searchSort,
     };
-    const body = await requestCuJson(CU_API.STOCK_MAIN_PATH, payload, timeout);
+    let body;
+    try {
+        body = await requestCuJson(CU_API.STOCK_MAIN_PATH, payload, options);
+    }
+    catch (error) {
+        const unavailableReason = cuStockUnavailableReason(error);
+        if (unavailableReason) {
+            return {
+                available: false,
+                unavailableReason,
+                totalCount: 0,
+                spellModifyYn: 'N',
+                items: [],
+            };
+        }
+        throw error;
+    }
+    if (body.resp_cd === '3000') {
+        throw new Error('CU 재고 API가 조회 실패 응답을 반환했습니다 (3000).');
+    }
     const result = body.data?.stockResult?.result;
     const rows = result?.rows || [];
     const items = rows
@@ -290,6 +302,8 @@ export async function fetchCuStock(params, options = {}) {
         reserveYn: toYnBoolean(fields.reserv_yn),
     }));
     return {
+        available: true,
+        unavailableReason: null,
         totalCount: toNumber(result?.total_count) || items.length,
         spellModifyYn: body.spellModifyYn || 'N',
         items,

package/dist/services/cu/index.js

@@ -10,12 +10,22 @@ const CU_METADATA = {
     description: 'CU 매장 탐색 및 상품 재고 조회 서비스',
 };
 class CuService {
+    options;
     metadata = CU_METADATA;
+    constructor(options = {}) {
+        this.options = options;
+    }
     getTools() {
-        return [createFindNearbyStoresTool(), createCheckInventoryTool()];
+        return [
+            createFindNearbyStoresTool(this.options.zyteApiKey),
+            createCheckInventoryTool({
+                zyteApiKey: this.options.zyteApiKey,
+                googleMapsApiKey: this.options.googleMapsApiKey,
+            }),
+        ];
     }
 }
-export function createCuService() {
-    return new CuService();
+export function createCuService(options = {}) {
+    return new CuService(options);
 }
 export * from './types.js';

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

@@ -4,7 +4,7 @@
 import * as z from 'zod';
 import { fetchCuStock, fetchCuStores, geocodeCuAddress } from '../client.js';
 async function checkInventory(args) {
-    const { keyword, latitude, longitude, storeKeyword = '', size = 20, offset = 0, searchSort = 'recom', storeLimit = 10, timeoutMs = 15000, } = args;
+    const { keyword, latitude, longitude, storeKeyword = '', size = 20, offset = 0, searchSort = 'recom', storeLimit = 10, timeoutMs = 15000, zyteApiKey, googleMapsApiKey, } = args;
     if (!keyword || keyword.trim().length === 0) {
         throw new Error('상품 검색어(keyword)를 입력해주세요.');
     }
@@ -15,61 +15,73 @@ async function checkInventory(args) {
         searchSort,
     }, {
         timeout: timeoutMs,
+        apiKey: zyteApiKey,
     });
     const firstStockItem = stockResult.items.find((item) => item.itemCode.trim().length > 0) || null;
     const hasInputLocation = typeof latitude === 'number' && typeof longitude === 'number';
     const resolvedLatitude = hasInputLocation ? latitude : undefined;
     const resolvedLongitude = hasInputLocation ? longitude : undefined;
-    let storeResult = null;
-    // 좌표 미입력 + 매장 키워드 입력 시, 키워드 기반 매장 검색 결과를 우선 사용합니다.
-    if (!hasInputLocation && storeKeyword.trim().length > 0) {
-        const keywordStoreResult = await fetchCuStores({
-            searchWord: storeKeyword,
-        }, {
-            timeout: timeoutMs,
-        });
-        const firstAddress = keywordStoreResult.stores.find((store) => store.address.trim().length > 0)?.address || '';
-        if (firstAddress.length > 0) {
-            const googleMapsApiKey = process.env.GOOGLE_MAPS_API_KEY;
-            const geocoded = await geocodeCuAddress(firstAddress, {
+    let storeResult = storeLimit <= 0 ? { totalCount: 0, stores: [] } : null;
+    let storeUnavailableReason = null;
+    try {
+        // 좌표 미입력 + 매장 키워드 입력 시, 키워드 기반 매장 검색 결과를 우선 사용합니다.
+        if (!storeResult && !hasInputLocation && storeKeyword.trim().length > 0) {
+            const keywordStoreResult = await fetchCuStores({
+                searchWord: storeKeyword,
+            }, {
                 timeout: timeoutMs,
-                googleMapsApiKey,
+                apiKey: zyteApiKey,
             });
-            if (geocoded) {
-                const hasStockSeed = !!firstStockItem?.itemCode;
-                storeResult = await fetchCuStores({
-                    latitude: geocoded.latitude,
-                    longitude: geocoded.longitude,
-                    searchWord: storeKeyword,
-                    itemCd: firstStockItem?.itemCode || '',
-                    onItemNo: firstStockItem?.onItemNo || '',
-                    jipCd: firstStockItem?.itemCode || '',
-                    isRecommend: hasStockSeed ? 'Y' : '',
-                    recommendId: hasStockSeed ? 'stock' : '',
-                    pageType: hasStockSeed ? 'search_improve stock_sch_improve' : 'search_improve',
-                }, {
+            const firstAddress = keywordStoreResult.stores.find((store) => store.address.trim().length > 0)?.address || '';
+            if (firstAddress.length > 0) {
+                const geocoded = await geocodeCuAddress(firstAddress, {
                     timeout: timeoutMs,
+                    googleMapsApiKey: googleMapsApiKey || process.env.GOOGLE_MAPS_API_KEY,
                 });
+                if (geocoded) {
+                    const hasStockSeed = !!firstStockItem?.itemCode;
+                    storeResult = await fetchCuStores({
+                        latitude: geocoded.latitude,
+                        longitude: geocoded.longitude,
+                        searchWord: storeKeyword,
+                        itemCd: firstStockItem?.itemCode || '',
+                        onItemNo: firstStockItem?.onItemNo || '',
+                        jipCd: firstStockItem?.itemCode || '',
+                        isRecommend: hasStockSeed ? 'Y' : '',
+                        recommendId: hasStockSeed ? 'stock' : '',
+                        pageType: hasStockSeed ? 'search_improve stock_sch_improve' : 'search_improve',
+                    }, {
+                        timeout: timeoutMs,
+                        apiKey: zyteApiKey,
+                    });
+                }
             }
+            storeResult ||= keywordStoreResult;
+        }
+        if (!storeResult) {
+            const hasStockSeed = !!firstStockItem?.itemCode;
+            storeResult = await fetchCuStores({
+                latitude: resolvedLatitude,
+                longitude: resolvedLongitude,
+                searchWord: storeKeyword,
+                itemCd: firstStockItem?.itemCode || '',
+                onItemNo: firstStockItem?.onItemNo || '',
+                jipCd: firstStockItem?.itemCode || '',
+                isRecommend: hasStockSeed ? 'Y' : '',
+                recommendId: hasStockSeed ? 'stock' : '',
+                pageType: hasStockSeed ? 'search_improve stock_sch_improve' : 'search_improve',
+            }, {
+                timeout: timeoutMs,
+                apiKey: zyteApiKey,
+            });
         }
-        storeResult ||= keywordStoreResult;
     }
-    if (!storeResult) {
-        const hasStockSeed = !!firstStockItem?.itemCode;
-        storeResult = await fetchCuStores({
-            latitude: resolvedLatitude,
-            longitude: resolvedLongitude,
-            searchWord: storeKeyword,
-            itemCd: firstStockItem?.itemCode || '',
-            onItemNo: firstStockItem?.onItemNo || '',
-            jipCd: firstStockItem?.itemCode || '',
-            isRecommend: hasStockSeed ? 'Y' : '',
-            recommendId: hasStockSeed ? 'stock' : '',
-            pageType: hasStockSeed ? 'search_improve stock_sch_improve' : 'search_improve',
-        }, {
-            timeout: timeoutMs,
-        });
+    catch (error) {
+        storeUnavailableReason =
+            error instanceof Error ? error.message : 'CU 매장 조회 중 알 수 없는 오류가 발생했습니다.';
+        storeResult = { totalCount: 0, stores: [] };
     }
+    storeResult ||= { totalCount: 0, stores: [] };
     const limitedStores = storeResult.stores.slice(0, storeLimit);
     const result = {
         keyword,
@@ -83,6 +95,8 @@ async function checkInventory(args) {
             ? { latitude: resolvedLatitude, longitude: resolvedLongitude }
             : null,
         nearbyStores: {
+            available: storeUnavailableReason === null,
+            unavailableReason: storeUnavailableReason,
             totalCount: storeResult.totalCount,
             count: limitedStores.length,
             stockItemCode: firstStockItem?.itemCode || null,
@@ -90,6 +104,8 @@ async function checkInventory(args) {
             stores: limitedStores,
         },
         inventory: {
+            available: stockResult.available,
+            unavailableReason: stockResult.unavailableReason,
             totalCount: stockResult.totalCount,
             count: stockResult.items.length,
             spellModifyYn: stockResult.spellModifyYn,
@@ -100,7 +116,7 @@ async function checkInventory(args) {
         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
 }
-export function createCheckInventoryTool() {
+export function createCheckInventoryTool(options = {}) {
     return {
         name: 'cu_check_inventory',
         metadata: {
@@ -118,6 +134,10 @@ export function createCheckInventoryTool() {
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },
-        handler: checkInventory,
+        handler: ((args) => checkInventory({
+            ...args,
+            zyteApiKey: options.zyteApiKey ?? args.zyteApiKey,
+            googleMapsApiKey: options.googleMapsApiKey ?? args.googleMapsApiKey,
+        })),
     };
 }

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

@@ -4,13 +4,14 @@
 import * as z from 'zod';
 import { fetchCuStores } from '../client.js';
 async function findNearbyStores(args) {
-    const { latitude, longitude, keyword = '', limit = 20, timeoutMs = 15000, } = args;
+    const { latitude, longitude, keyword = '', limit = 20, timeoutMs = 15000, zyteApiKey, } = args;
     const { totalCount, stores } = await fetchCuStores({
         latitude,
         longitude,
         searchWord: keyword,
     }, {
         timeout: timeoutMs,
+        apiKey: zyteApiKey,
     });
     const limitedStores = stores.slice(0, limit);
     return {
@@ -30,7 +31,7 @@ async function findNearbyStores(args) {
         ],
     };
 }
-export function createFindNearbyStoresTool() {
+export function createFindNearbyStoresTool(zyteApiKey) {
     return {
         name: 'cu_find_nearby_stores',
         metadata: {
@@ -44,6 +45,6 @@ export function createFindNearbyStoresTool() {
                 timeoutMs: z.number().optional().default(15000).describe('요청 제한 시간(ms, 기본값: 15000)'),
             },
         },
-        handler: findNearbyStores,
+        handler: ((args) => findNearbyStores({ ...args, zyteApiKey: zyteApiKey ?? args.zyteApiKey })),
     };
 }

package/dist/services/cu/upstreamError.js

@@ -0,0 +1,11 @@
+/** CU 재고 조회 불가 사유를 응답 형식과 전송 실패에 따라 구분합니다. */
+import { HttpError, UnexpectedHtmlResponseError } from '../../utils/http.js';
+export function cuStockUnavailableReason(error) {
+    if (error instanceof UnexpectedHtmlResponseError) {
+        return 'CU 재고 API가 JSON 대신 HTML을 반환하여 재고를 확인할 수 없습니다.';
+    }
+    if (error instanceof HttpError && [400, 403, 429].includes(error.status)) {
+        return `CU 재고 API가 차단되었습니다 (${error.status} Request Blocked).`;
+    }
+    return null;
+}

package/dist/services/dtryx/api.js

@@ -0,0 +1,25 @@
+/**
+ * 디트릭스(Dtryx) API 엔드포인트 및 상수
+ *
+ * 디트릭스는 국내 독립·예술영화관 다수가 공용으로 사용하는 예매 플랫폼입니다.
+ * 공개 조회 엔드포인트이며 별도 인증 키가 필요하지 않습니다.
+ */
+export const DTRYX_API = {
+    BASE_URL: 'https://api.dtryx.com:30443',
+    THIRDPARTY_PATH: '/dtryx/cms/thirdparty/movie',
+    CHANNEL_CODE: 'homepage',
+    ENDPOINTS: {
+        TIMETABLE_LIST: 'third-party-type2-timetable-list',
+        PLAY_DATE_LIST: 'third-party-type2-timetable-play-date-list',
+        MOVIE_NOW: 'third-party-type2-movie-now',
+    },
+    /**
+     * 엔드포인트별 고정 작업 식별자입니다.
+     * 각 극장 홈페이지에 공개된 값과 동일합니다.
+     */
+    WORK_GUIDS: {
+        TIMETABLE_LIST: '37E0BA0F-DA5F-4376-9BA4-B5D27286AB87',
+        PLAY_DATE_LIST: '324A2914-AB19-42A3-BDFE-58A08B2DC35D',
+        MOVIE_NOW: '6D741A36-A973-4BC4-87B4-2475E6654114',
+    },
+};

package/dist/services/dtryx/client.js

@@ -0,0 +1,133 @@
+/**
+ * 디트릭스 API 클라이언트
+ */
+import { formatTime, toNumber, toYyyymmdd } from '../../utils/format.js';
+import { createTimeoutController } from '../../utils/http.js';
+import { DTRYX_API } from './api.js';
+const DEFAULT_TIMEOUT_MS = 15000;
+/**
+ * 디트릭스는 `PlaySDT` 를 `YYYY-MM-DD` 로만 받습니다.
+ * `YYYYMMDD` 로 보내면 오류 없이 `RecordCount: 0` 이 반환되므로 항상 변환합니다.
+ */
+export function toDashedDate(playDate) {
+    if (/^\d{8}$/.test(playDate)) {
+        return `${playDate.slice(0, 4)}-${playDate.slice(4, 6)}-${playDate.slice(6, 8)}`;
+    }
+    return playDate;
+}
+/** 출력용으로 `YYYYMMDD` 형태로 되돌립니다. */
+export function toCompactDate(playDate) {
+    return playDate.replace(/-/g, '');
+}
+async function requestDtryx(endpoint, workGuid, params, timeout = DEFAULT_TIMEOUT_MS) {
+    const { controller, timeoutId } = createTimeoutController(timeout);
+    const query = new URLSearchParams({
+        ChannelCd: DTRYX_API.CHANNEL_CODE,
+        EngVerYn: 'N',
+        WorkGuID: workGuid,
+        ...params,
+    });
+    const url = `${DTRYX_API.BASE_URL}${DTRYX_API.THIRDPARTY_PATH}/${endpoint}?${query.toString()}`;
+    try {
+        const response = await fetch(url, {
+            method: 'GET',
+            headers: {
+                Accept: 'application/json, text/javascript, */*; q=0.01',
+            },
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`디트릭스 API 호출 실패: ${response.status}`);
+        }
+        const body = await response.json();
+        if (typeof body !== 'object' ||
+            body === null ||
+            !('RetCode' in body) ||
+            body.RetCode !== 'success' ||
+            !('Recordset' in body) ||
+            !Array.isArray(body.Recordset) ||
+            !body.Recordset.every((item) => typeof item === 'object' && item !== null && !Array.isArray(item))) {
+            throw new Error('디트릭스 API 응답 오류: RetCode 또는 Recordset이 유효하지 않습니다.');
+        }
+        return body;
+    }
+    catch (error) {
+        if (error instanceof Error && error.name === 'AbortError') {
+            throw new Error('디트릭스 API 호출 시간 초과');
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+function buildScheduleId(cinemaCode, playDate, screenCode, showSeq) {
+    return `${playDate}-${cinemaCode}-${screenCode}-${showSeq}`;
+}
+/** 상영 회차와 좌석 현황을 조회합니다. */
+export async function fetchDtryxTimetable(params) {
+    const playDate = params.playDate || toYyyymmdd();
+    const response = await requestDtryx(DTRYX_API.ENDPOINTS.TIMETABLE_LIST, DTRYX_API.WORK_GUIDS.TIMETABLE_LIST, {
+        BrandCd: params.brandCode,
+        CinemaCd: params.cinemaCode,
+        PlaySDT: toDashedDate(playDate),
+        ImgSize: 'small',
+    }, params.timeout);
+    return response.Recordset.filter((item) => item.CinemaCd && item.MovieCd && item.ScreenCd).map((item) => {
+        const totalSeats = toNumber(item.TotalSeatCnt);
+        const remainingSeats = toNumber(item.RemainSeatCnt);
+        const compactDate = toCompactDate(item.PlaySDT || playDate);
+        const cinemaCode = String(item.CinemaCd);
+        const screenCode = String(item.ScreenCd);
+        const showSeq = String(item.ShowSeq ?? '');
+        return {
+            scheduleId: buildScheduleId(cinemaCode, compactDate, screenCode, showSeq),
+            brandCode: params.brandCode,
+            cinemaCode,
+            cinemaName: item.CinemaNm || '',
+            screenCode,
+            screenName: item.ScreenNm || '',
+            movieCode: String(item.MovieCd),
+            movieName: item.MovieNm || '',
+            playDate: compactDate,
+            startTime: formatTime(item.StartTime),
+            endTime: formatTime(item.EndTime),
+            runningMinutes: toNumber(item.RunningTime),
+            rating: item.RatingNm || '',
+            totalSeats,
+            remainingSeats,
+            bookedSeats: Math.max(totalSeats - remainingSeats, 0),
+            planStatus: item.PlanStatus || '',
+        };
+    });
+}
+/** 예매 가능한 상영 날짜를 조회합니다. */
+export async function fetchDtryxPlayDates(params) {
+    const response = await requestDtryx(DTRYX_API.ENDPOINTS.PLAY_DATE_LIST, DTRYX_API.WORK_GUIDS.PLAY_DATE_LIST, {
+        BrandCd: params.brandCode,
+        CinemaCd: params.cinemaCode,
+        MovieCd: '',
+    }, params.timeout);
+    return response.Recordset.filter((item) => item.PlaySDT).map((item) => ({
+        playDate: toCompactDate(item.PlaySDT),
+        hidden: item.HiddenYn === 'Y',
+        rest: item.RestYn === 'Y',
+    }));
+}
+/** 현재 상영작 목록을 조회합니다. */
+export async function fetchDtryxNowShowing(params) {
+    const response = await requestDtryx(DTRYX_API.ENDPOINTS.MOVIE_NOW, DTRYX_API.WORK_GUIDS.MOVIE_NOW, {
+        BrandCd: params.brandCode,
+        CinemaCd: params.cinemaCode,
+        ImgSize: 'small',
+    }, params.timeout);
+    return response.Recordset.filter((item) => item.MovieCd && item.MovieNm).map((item) => ({
+        movieCode: String(item.MovieCd),
+        movieName: item.MovieNm,
+        rating: item.RatingNm || undefined,
+        runningMinutes: item.RunningTime === null || item.RunningTime === undefined
+            ? undefined
+            : toNumber(item.RunningTime),
+    }));
+}
+export { toYyyymmdd };

package/dist/services/dtryx/index.js

@@ -0,0 +1,24 @@
+/**
+ * 디트릭스(Dtryx) 서비스 프로바이더
+ *
+ * 국내 독립·예술영화관 다수가 공용으로 사용하는 예매 플랫폼을 조회합니다.
+ */
+import { createGetRemainingSeatsTool } from './tools/getRemainingSeats.js';
+import { createListCinemasTool } from './tools/listCinemas.js';
+import { createListNowShowingTool } from './tools/listNowShowing.js';
+const DTRYX_METADATA = {
+    id: 'dtryx',
+    name: '디트릭스',
+    version: '1.0.0',
+    description: '디트릭스 예매 플랫폼 기반 독립·예술영화관 목록, 상영작, 상영시간표·잔여 좌석 조회 서비스',
+};
+class DtryxService {
+    metadata = DTRYX_METADATA;
+    getTools() {
+        return [createListCinemasTool(), createListNowShowingTool(), createGetRemainingSeatsTool()];
+    }
+}
+export function createDtryxService() {
+    return new DtryxService();
+}
+export * from './types.js';