feat: 도메인 시스템 개선 + 검색 한글→영문 번역

주요 변경:
- Domain Agent 제거, 코드 직접 처리로 전환
- suggest_domains: 등록 가능 도메인만 표시, 10개 미만 시 재시도
- search_web: 한글 검색어 자동 영문 번역 (GPT-4o-mini)
- WHOIS: raw 데이터 파싱으로 상세 정보 추출
- 가격 조회: API 필드명 수정 (register_krw → krw)
- 동적 도구 로딩 시스템 추가
- 문서 정리 및 업데이트

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

src/index.ts

@@ -275,6 +275,121 @@ export default {
       }
     }
 
+    // Deposit API - 잔액 조회 (namecheap-api 전용)
+    if (url.pathname === '/api/deposit/balance' && request.method === 'GET') {
+      try {
+        const apiSecret = env.DEPOSIT_API_SECRET;
+        const authHeader = request.headers.get('X-API-Key');
+
+        if (!apiSecret || authHeader !== apiSecret) {
+          return Response.json({ error: 'Unauthorized' }, { status: 401 });
+        }
+
+        const telegramId = url.searchParams.get('telegram_id');
+        if (!telegramId) {
+          return Response.json({ error: 'telegram_id required' }, { status: 400 });
+        }
+
+        // 사용자 조회
+        const user = await env.DB.prepare(
+          'SELECT id FROM users WHERE telegram_id = ?'
+        ).bind(telegramId).first<{ id: number }>();
+
+        if (!user) {
+          return Response.json({ error: 'User not found' }, { status: 404 });
+        }
+
+        // 잔액 조회
+        const deposit = await env.DB.prepare(
+          'SELECT balance FROM user_deposits WHERE user_id = ?'
+        ).bind(user.id).first<{ balance: number }>();
+
+        return Response.json({
+          telegram_id: telegramId,
+          balance: deposit?.balance || 0,
+        });
+      } catch (error) {
+        console.error('[API] Deposit balance error:', error);
+        return Response.json({ error: String(error) }, { status: 500 });
+      }
+    }
+
+    // Deposit API - 잔액 차감 (namecheap-api 전용)
+    if (url.pathname === '/api/deposit/deduct' && request.method === 'POST') {
+      try {
+        const apiSecret = env.DEPOSIT_API_SECRET;
+        const authHeader = request.headers.get('X-API-Key');
+
+        if (!apiSecret || authHeader !== apiSecret) {
+          return Response.json({ error: 'Unauthorized' }, { status: 401 });
+        }
+
+        const body = await request.json() as {
+          telegram_id: string;
+          amount: number;
+          reason: string;
+          reference_id?: string;
+        };
+
+        if (!body.telegram_id || !body.amount || !body.reason) {
+          return Response.json({ error: 'telegram_id, amount, reason required' }, { status: 400 });
+        }
+
+        if (body.amount <= 0) {
+          return Response.json({ error: 'Amount must be positive' }, { status: 400 });
+        }
+
+        // 사용자 조회
+        const user = await env.DB.prepare(
+          'SELECT id FROM users WHERE telegram_id = ?'
+        ).bind(body.telegram_id).first<{ id: number }>();
+
+        if (!user) {
+          return Response.json({ error: 'User not found' }, { status: 404 });
+        }
+
+        // 현재 잔액 확인
+        const deposit = await env.DB.prepare(
+          'SELECT balance FROM user_deposits WHERE user_id = ?'
+        ).bind(user.id).first<{ balance: number }>();
+
+        const currentBalance = deposit?.balance || 0;
+        if (currentBalance < body.amount) {
+          return Response.json({
+            error: 'Insufficient balance',
+            current_balance: currentBalance,
+            required: body.amount,
+          }, { status: 400 });
+        }
+
+        // 트랜잭션: 잔액 차감 + 거래 기록
+        await env.DB.batch([
+          env.DB.prepare(
+            'UPDATE user_deposits SET balance = balance - ?, updated_at = CURRENT_TIMESTAMP WHERE user_id = ?'
+          ).bind(body.amount, user.id),
+          env.DB.prepare(
+            `INSERT INTO deposit_transactions (user_id, type, amount, status, description, confirmed_at)
+             VALUES (?, 'deduct', ?, 'confirmed', ?, CURRENT_TIMESTAMP)`
+          ).bind(user.id, body.amount, body.reason),
+        ]);
+
+        const newBalance = currentBalance - body.amount;
+
+        console.log(`[API] Deposit deducted: user=${body.telegram_id}, amount=${body.amount}, reason=${body.reason}`);
+
+        return Response.json({
+          success: true,
+          telegram_id: body.telegram_id,
+          deducted: body.amount,
+          previous_balance: currentBalance,
+          new_balance: newBalance,
+        });
+      } catch (error) {
+        console.error('[API] Deposit deduct error:', error);
+        return Response.json({ error: String(error) }, { status: 500 });
+      }
+    }
+
     // Telegram Webhook 처리
     if (url.pathname === '/webhook') {
       // 보안 검증

src/openai-service.ts

@@ -119,16 +119,30 @@ const tools = [
     type: 'function',
     function: {
       name: 'manage_domain',
-      description: '도메인을 관리합니다. 도메인 목록 조회, 도메인 정보 확인, 네임서버 조회/변경, 도메인 가용성 확인, 계정 잔액 조회, TLD 가격 조회 등을 수행할 수 있습니다.',
+      description: '도메인 관리 및 정보 조회. ".com 가격", ".io 가격" 같은 TLD 가격 조회, 도메인 등록, WHOIS 조회, 네임서버 관리 등을 처리합니다.',
       parameters: {
         type: 'object',
         properties: {
-          query: {
+          action: {
             type: 'string',
-            description: '도메인 관리 요청 (예: 도메인 목록 보여줘, anvil.it.com 네임서버 확인, example.com 등록 가능한지 확인)',
+            enum: ['register', 'check', 'whois', 'list', 'info', 'get_ns', 'set_ns', 'price'],
+            description: 'price: TLD 가격 조회 (.com 가격, .io 가격), register: 도메인 등록, check: 가용성 확인, whois: WHOIS 조회, list: 내 도메인 목록, info: 도메인 상세정보, get_ns/set_ns: 네임서버 조회/변경',
+          },
+          domain: {
+            type: 'string',
+            description: '대상 도메인 또는 TLD (예: example.com, .com, com). price action에서는 TLD만 전달 가능',
+          },
+          nameservers: {
+            type: 'array',
+            items: { type: 'string' },
+            description: '설정할 네임서버 목록. set_ns action에만 필요 (예: ["ns1.example.com", "ns2.example.com"])',
+          },
+          tld: {
+            type: 'string',
+            description: 'TLD. price action에서 사용 (예: tld="com" 또는 domain=".com" 또는 domain="com" 모두 가능)',
           },
         },
-        required: ['query'],
+        required: ['action'],
       },
     },
   },
@@ -149,10 +163,222 @@ const tools = [
       },
     },
   },
+  {
+    type: 'function',
+    function: {
+      name: 'suggest_domains',
+      description: '키워드나 비즈니스 설명을 기반으로 도메인 이름을 추천합니다. 창의적인 도메인 아이디어를 생성하고 가용성을 확인하여 등록 가능한 도메인만 가격과 함께 제안합니다. "도메인 추천", "도메인 제안", "도메인 아이디어" 등의 요청에 사용하세요.',
+      parameters: {
+        type: 'object',
+        properties: {
+          keywords: {
+            type: 'string',
+            description: '도메인 추천을 위한 키워드나 비즈니스 설명 (예: 커피숍, IT 스타트업, 서버 호스팅)',
+          },
+        },
+        required: ['keywords'],
+      },
+    },
+  },
 ];
 
+// ============================================
+// 동적 도구 로딩 시스템
+// ============================================
+
+// 도구 카테고리 정의
+const TOOL_CATEGORIES: Record<string, string[]> = {
+  domain: ['manage_domain', 'suggest_domains'],
+  deposit: ['manage_deposit'],
+  weather: ['get_weather'],
+  search: ['search_web', 'lookup_docs'],
+  utility: ['get_current_time', 'calculate'],
+};
+
+// 카테고리 감지 패턴 (느슨하게)
+const CATEGORY_PATTERNS: Record<string, RegExp> = {
+  domain: /도메인|네임서버|whois|dns|tld|등록|\.com|\.net|\.io|\.kr|\.org/i,
+  deposit: /입금|충전|잔액|계좌|예치금|송금|돈/i,
+  weather: /날씨|기온|비|눈|맑|흐림|더워|추워/i,
+  search: /검색|찾아|뭐야|뭔가요|뉴스|최신/i,
+};
+
+// 메시지 기반 도구 선택
+function selectToolsForMessage(message: string): typeof tools {
+  const selectedCategories = new Set<string>(['utility']);  // 항상 포함
+
+  for (const [category, pattern] of Object.entries(CATEGORY_PATTERNS)) {
+    if (pattern.test(message)) {
+      selectedCategories.add(category);
+    }
+  }
+
+  // 패턴 매칭 없으면 전체 도구 사용 (폴백)
+  if (selectedCategories.size === 1) {
+    console.log('[ToolSelector] 패턴 매칭 없음 → 전체 도구 사용');
+    return tools;
+  }
+
+  const selectedNames = new Set(
+    [...selectedCategories].flatMap(cat => TOOL_CATEGORIES[cat] || [])
+  );
+
+  const selectedTools = tools.filter(t => selectedNames.has(t.function.name));
+
+  console.log('[ToolSelector] 메시지:', message);
+  console.log('[ToolSelector] 카테고리:', [...selectedCategories].join(', '));
+  console.log('[ToolSelector] 선택된 도구:', selectedTools.map(t => t.function.name).join(', '));
+
+  return selectedTools;
+}
+
+// 도메인 추천 함수
+async function suggestDomains(keywords: string, apiKey: string): Promise<string> {
+  const namecheapApiKey = '05426957210b42e752950f565ea82a3f48df9cccfdce9d82cd9817011968076e';
+  const namecheapApiUrl = 'https://namecheap-api.anvil.it.com';
+  const TARGET_COUNT = 10;
+  const MAX_RETRIES = 3;
+
+  try {
+    const availableDomains: { domain: string; price?: number }[] = [];
+    const checkedDomains = new Set<string>();
+    let retryCount = 0;
+
+    // 10개 이상 등록 가능 도메인을 찾을 때까지 반복
+    while (availableDomains.length < TARGET_COUNT && retryCount < MAX_RETRIES) {
+      retryCount++;
+      const excludeList = [...checkedDomains].slice(-30).join(', ');
+
+      // Step 1: GPT에게 도메인 아이디어 생성 요청
+      const ideaResponse = await fetch('https://api.openai.com/v1/chat/completions', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+          model: 'gpt-4o-mini',
+          messages: [
+            {
+              role: 'system',
+              content: `당신은 도메인 이름 전문가입니다. 주어진 키워드/비즈니스 설명을 바탕으로 창의적이고 기억하기 쉬운 도메인 이름을 제안합니다.
+
+규칙:
+- 정확히 15개의 도메인 이름을 제안하세요
+- 다양한 TLD 사용: .com, .io, .net, .co, .app, .dev, .site, .xyz, .me
+- 짧고 기억하기 쉬운 이름 (2-3 단어 조합)
+- 트렌디한 접미사 활용: hub, lab, spot, nest, base, cloud, stack, flow, zone, pro
+- JSON 배열로만 응답하세요. 설명 없이 도메인 목록만.
+${excludeList ? `- 다음 도메인은 제외하세요: ${excludeList}` : ''}
+
+예시 응답:
+["coffeenest.com", "brewlab.io", "beanspot.co"]`
+            },
+            {
+              role: 'user',
+              content: `키워드: ${keywords}`
+            }
+          ],
+          max_tokens: 500,
+          temperature: 0.9,
+        }),
+      });
+
+      if (!ideaResponse.ok) {
+        if (availableDomains.length > 0) break; // 이미 찾은 게 있으면 그것으로 진행
+        return '🚫 도메인 아이디어 생성 중 오류가 발생했습니다.';
+      }
+
+      const ideaData = await ideaResponse.json() as any;
+      const ideaContent = ideaData.choices?.[0]?.message?.content || '[]';
+
+      let domains: string[];
+      try {
+        domains = JSON.parse(ideaContent);
+        if (!Array.isArray(domains)) domains = [];
+      } catch {
+        const domainRegex = /[\w-]+\.(com|io|net|co|app|dev|site|org|xyz|me)/gi;
+        domains = ideaContent.match(domainRegex) || [];
+      }
+
+      // 이미 체크한 도메인 제외
+      const newDomains = domains.filter(d => !checkedDomains.has(d.toLowerCase()));
+      if (newDomains.length === 0) continue;
+
+      newDomains.forEach(d => checkedDomains.add(d.toLowerCase()));
+
+      // Step 2: 가용성 확인
+      const checkResponse = await fetch(`${namecheapApiUrl}/domains/check`, {
+        method: 'POST',
+        headers: {
+          'X-API-Key': namecheapApiKey,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ domains: newDomains }),
+      });
+
+      if (!checkResponse.ok) continue;
+
+      const checkRaw = await checkResponse.json() as Record<string, boolean>;
+
+      // 등록 가능한 도메인만 추가
+      for (const [domain, isAvailable] of Object.entries(checkRaw)) {
+        if (isAvailable && availableDomains.length < TARGET_COUNT) {
+          availableDomains.push({ domain });
+        }
+      }
+    }
+
+    if (availableDomains.length === 0) {
+      return `🎯 **${keywords}** 관련 도메인:\n\n❌ 등록 가능한 도메인을 찾지 못했습니다.\n다른 키워드로 다시 시도해주세요.`;
+    }
+
+    // Step 3: 가격 조회
+    const tldPrices: Record<string, number> = {};
+    const uniqueTlds = [...new Set(availableDomains.map(d => d.domain.split('.').pop() || ''))];
+
+    for (const tld of uniqueTlds) {
+      try {
+        const priceRes = await fetch(`${namecheapApiUrl}/prices/${tld}`, {
+          headers: { 'X-API-Key': namecheapApiKey },
+        });
+        if (priceRes.ok) {
+          const priceData = await priceRes.json() as { krw?: number };
+          tldPrices[tld] = priceData.krw || 0;
+        }
+      } catch {
+        // 가격 조회 실패 시 무시
+      }
+    }
+
+    // Step 4: 결과 포맷팅 (등록 가능한 것만)
+    let response = `🎯 **${keywords}** 관련 도메인:\n\n`;
+
+    availableDomains.forEach((d, i) => {
+      const tld = d.domain.split('.').pop() || '';
+      const price = tldPrices[tld];
+      const priceStr = price ? `${price.toLocaleString()}원/년` : '가격 조회 중';
+      response += `${i + 1}. ${d.domain} - ${priceStr}\n`;
+    });
+
+    response += `\n등록하시려면 번호나 도메인명을 말씀해주세요.`;
+
+    return response;
+  } catch (error) {
+    console.error('[suggestDomains] 오류:', error);
+    return `🚫 도메인 추천 중 오류가 발생했습니다: ${String(error)}`;
+  }
+}
+
 // Namecheap API 호출 (allowedDomains로 필터링)
-async function callNamecheapApi(funcName: string, funcArgs: Record<string, any>, allowedDomains: string[]): Promise<any> {
+async function callNamecheapApi(
+  funcName: string,
+  funcArgs: Record<string, any>,
+  allowedDomains: string[],
+  telegramUserId?: string,
+  db?: D1Database,
+  userId?: number
+): Promise<any> {
   const apiKey = '05426957210b42e752950f565ea82a3f48df9cccfdce9d82cd9817011968076e';
   const apiUrl = 'https://namecheap-api.anvil.it.com';
 
@@ -322,130 +548,256 @@ async function callNamecheapApi(funcName: string, funcArgs: Record<string, any>,
         return { error: `WHOIS 조회 오류: ${String(error)}` };
       }
     }
+    case 'register_domain': {
+      if (!telegramUserId) {
+        return { error: '도메인 등록에는 로그인이 필요합니다.' };
+      }
+      const res = await fetch(`${apiUrl}/domains/register`, {
+        method: 'POST',
+        headers: { 'X-API-Key': apiKey, 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+          domain: funcArgs.domain,
+          years: funcArgs.years || 1,
+          telegram_id: telegramUserId,
+        }),
+      });
+      const result = await res.json() as any;
+      if (!res.ok) {
+        return { error: result.detail || '도메인 등록 실패' };
+      }
+      // 등록 성공 시 user_domains 테이블에 추가
+      if (result.registered && db && userId) {
+        try {
+          await db.prepare(
+            'INSERT INTO user_domains (user_id, domain, verified, created_at) VALUES (?, ?, 1, datetime("now"))'
+          ).bind(userId, funcArgs.domain).run();
+          console.log(`[register_domain] user_domains에 추가: user_id=${userId}, domain=${funcArgs.domain}`);
+        } catch (dbError) {
+          console.error('[register_domain] user_domains 추가 실패:', dbError);
+          result.warning = result.warning || '';
+          result.warning += ' (DB 기록 실패 - 수동 추가 필요)';
+        }
+      }
+      return result;
+    }
     default:
       return { error: `Unknown function: ${funcName}` };
   }
 }
 
-// 도메인 에이전트 (Assistants API - 기존 Agent 활용)
-async function callDomainAgent(
-  apiKey: string,
-  assistantId: string,
-  query: string,
-  allowedDomains: string[] = []
+// 도메인 작업 직접 실행 (Agent 없이 코드로 처리)
+async function executeDomainAction(
+  action: string,
+  args: { domain?: string; nameservers?: string[]; tld?: string },
+  allowedDomains: string[],
+  telegramUserId?: string,
+  db?: D1Database,
+  userId?: number
 ): Promise<string> {
-  try {
-    // 1. Thread 생성
-    const threadRes = await fetch('https://api.openai.com/v1/threads', {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${apiKey}`,
-        'OpenAI-Beta': 'assistants=v2',
-      },
-      body: JSON.stringify({}),
-    });
-    if (!threadRes.ok) return `Thread 생성 실패 (${threadRes.status})`;
-    const thread = await threadRes.json() as { id: string };
+  const { domain, nameservers, tld } = args;
 
-    // 2. 메시지 추가 (허용 도메인 명시 + 응답 스타일 지시)
-    const domainList = allowedDomains.join(', ');
-    const instructions = `[시스템 지시]
-- 관리 가능 도메인: ${domainList}
-- 한국어로 질문하면 한국어로 답변하고, 가격은 원화(KRW)만 표시
-- 영어로 질문하면 영어로 답변하고, 가격은 달러(USD)로 표시
-- 가격 응답 시 불필요한 달러 환산 정보 생략
+  switch (action) {
+    case 'list': {
+      const result = await callNamecheapApi('list_domains', {}, allowedDomains, telegramUserId, db, userId);
+      if (result.error) return `🚫 ${result.error}`;
+      if (!result.length) return '📋 등록된 도메인이 없습니다.';
+      const list = result.map((d: any) => `• ${d.name} (만료: ${d.expires})`).join('\n');
+      return `📋 내 도메인 목록 (${result.length}개)\n\n${list}`;
+    }
 
-[사용자 질문]
-${query}`;
-    await fetch(`https://api.openai.com/v1/threads/${thread.id}/messages`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${apiKey}`,
-        'OpenAI-Beta': 'assistants=v2',
-      },
-      body: JSON.stringify({
-        role: 'user',
-        content: instructions
-      }),
-    });
+    case 'info': {
+      if (!domain) return '🚫 도메인을 지정해주세요.';
+      const result = await callNamecheapApi('get_domain_info', { domain }, allowedDomains, telegramUserId, db, userId);
+      if (result.error) return `🚫 ${result.error}`;
+      return `📋 ${domain} 정보\n\n• 생성일: ${result.created}\n• 만료일: ${result.expires}\n• 자동갱신: ${result.auto_renew ? '✅' : '❌'}\n• 잠금: ${result.is_locked ? '🔒' : '🔓'}\n• WHOIS Guard: ${result.whois_guard ? '✅' : '❌'}`;
+    }
 
-    // 3. Run 생성
-    const runRes = await fetch(`https://api.openai.com/v1/threads/${thread.id}/runs`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${apiKey}`,
-        'OpenAI-Beta': 'assistants=v2',
-      },
-      body: JSON.stringify({ assistant_id: assistantId }),
-    });
-    if (!runRes.ok) return `Run 생성 실패 (${runRes.status})`;
-    let run = await runRes.json() as { id: string; status: string; required_action?: any };
+    case 'get_ns': {
+      if (!domain) return '🚫 도메인을 지정해주세요.';
+      const result = await callNamecheapApi('get_nameservers', { domain }, allowedDomains, telegramUserId, db, userId);
+      if (result.error) return `🚫 ${result.error}`;
+      const nsList = (result.nameservers || result).map((ns: string) => `• ${ns}`).join('\n');
+      return `🌐 ${domain} 네임서버\n\n${nsList}`;
+    }
 
-    // 4. 완료까지 폴링 및 Function Calling 처리
-    let maxPolls = 30; // 최대 15초
-    while ((run.status === 'queued' || run.status === 'in_progress' || run.status === 'requires_action') && maxPolls > 0) {
-      if (run.status === 'requires_action') {
-        const toolCalls = run.required_action?.submit_tool_outputs?.tool_calls || [];
-        const toolOutputs = [];
+    case 'set_ns': {
+      if (!domain) return '🚫 도메인을 지정해주세요.';
+      if (!nameservers?.length) return '🚫 네임서버를 지정해주세요.';
+      if (!allowedDomains.includes(domain)) return `🚫 ${domain}은 관리 권한이 없습니다.`;
+      const result = await callNamecheapApi('set_nameservers', { domain, nameservers }, allowedDomains, telegramUserId, db, userId);
+      if (result.error) return `🚫 ${result.error}`;
+      return `✅ ${domain} 네임서버 변경 완료\n\n${nameservers.map(ns => `• ${ns}`).join('\n')}`;
+    }
 
-        for (const toolCall of toolCalls) {
-          const funcName = toolCall.function.name;
-          const funcArgs = JSON.parse(toolCall.function.arguments);
-          const result = await callNamecheapApi(funcName, funcArgs, allowedDomains);
-          toolOutputs.push({
-            tool_call_id: toolCall.id,
-            output: JSON.stringify(result),
-          });
-        }
+    case 'check': {
+      if (!domain) return '🚫 도메인을 지정해주세요.';
+      const result = await callNamecheapApi('check_domains', { domains: [domain] }, allowedDomains, telegramUserId, db, userId);
+      if (result.error) return `🚫 ${result.error}`;
+      const available = result[domain];
+      if (available) {
+        // 가격도 함께 조회
+        const domainTld = domain.split('.').pop() || '';
+        const priceResult = await callNamecheapApi('get_price', { tld: domainTld }, allowedDomains, telegramUserId, db, userId);
+        const price = priceResult.krw || priceResult.register_krw;
+        return `✅ ${domain}은 등록 가능합니다.\n\n💰 가격: ${price?.toLocaleString()}원/년\n\n등록하시려면 "${domain} 등록해줘"라고 말씀해주세요.`;
+      }
+      return `❌ ${domain}은 이미 등록된 도메인입니다.`;
+    }
 
-        // Tool outputs 제출
-        const submitRes = await fetch(`https://api.openai.com/v1/threads/${thread.id}/runs/${run.id}/submit_tool_outputs`, {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            'Authorization': `Bearer ${apiKey}`,
-            'OpenAI-Beta': 'assistants=v2',
-          },
-          body: JSON.stringify({ tool_outputs: toolOutputs }),
-        });
-        run = await submitRes.json() as { id: string; status: string; required_action?: any };
+    case 'whois': {
+      if (!domain) return '🚫 도메인을 지정해주세요.';
+      const result = await callNamecheapApi('whois_lookup', { domain }, allowedDomains, telegramUserId, db, userId);
+      if (result.error) return `🚫 ${result.error}`;
+
+      // ccSLD WHOIS 미지원
+      if (result.whois_supported === false) {
+        return `🔍 ${domain} WHOIS\n\n⚠️ ${result.message}\n💡 ${result.suggestion}`;
       }
 
-      await new Promise(resolve => setTimeout(resolve, 500));
-      maxPolls--;
+      // raw WHOIS 데이터에서 주요 정보 추출
+      const raw = result.raw || '';
+      const extractField = (patterns: RegExp[]): string => {
+        for (const pattern of patterns) {
+          const match = raw.match(pattern);
+          if (match) return match[1].trim();
+        }
+        return '-';
+      };
 
-      const statusRes = await fetch(`https://api.openai.com/v1/threads/${thread.id}/runs/${run.id}`, {
-        headers: {
-          'Authorization': `Bearer ${apiKey}`,
-          'OpenAI-Beta': 'assistants=v2',
-        },
-      });
-      run = await statusRes.json() as { id: string; status: string; required_action?: any };
+      const created = extractField([
+        /Creation Date:\s*(.+)/i,
+        /Created Date:\s*(.+)/i,
+        /Registration Date:\s*(.+)/i,
+        /created:\s*(.+)/i,
+      ]);
+      const expires = extractField([
+        /Registry Expiry Date:\s*(.+)/i,
+        /Expiration Date:\s*(.+)/i,
+        /Expiry Date:\s*(.+)/i,
+        /expires:\s*(.+)/i,
+      ]);
+      const updated = extractField([
+        /Updated Date:\s*(.+)/i,
+        /Last Updated:\s*(.+)/i,
+        /modified:\s*(.+)/i,
+      ]);
+      const registrar = extractField([
+        /Registrar:\s*(.+)/i,
+        /Sponsoring Registrar:\s*(.+)/i,
+      ]);
+      const registrarUrl = extractField([
+        /Registrar URL:\s*(.+)/i,
+      ]);
+      const registrant = extractField([
+        /Registrant Organization:\s*(.+)/i,
+        /Registrant Name:\s*(.+)/i,
+        /org:\s*(.+)/i,
+      ]);
+      const registrantCountry = extractField([
+        /Registrant Country:\s*(.+)/i,
+        /Registrant State\/Province:\s*(.+)/i,
+      ]);
+      const statusMatch = raw.match(/Domain Status:\s*(.+)/gi);
+      const statuses = statusMatch
+        ? statusMatch.map(s => s.replace(/Domain Status:\s*/i, '').split(' ')[0].trim()).slice(0, 3)
+        : [];
+      const dnssec = extractField([
+        /DNSSEC:\s*(.+)/i,
+      ]);
+      const nsMatch = raw.match(/Name Server:\s*(.+)/gi);
+      const nameservers = nsMatch
+        ? nsMatch.map(ns => ns.replace(/Name Server:\s*/i, '').trim()).slice(0, 4)
+        : [];
+
+      let response = `🔍 ${domain} WHOIS 정보\n\n`;
+      response += `📅 날짜\n`;
+      response += `• 등록일: ${created}\n`;
+      response += `• 만료일: ${expires}\n`;
+      if (updated !== '-') response += `• 수정일: ${updated}\n`;
+      response += `\n🏢 등록 정보\n`;
+      response += `• 등록기관: ${registrar}\n`;
+      if (registrarUrl !== '-') response += `• URL: ${registrarUrl}\n`;
+      if (registrant !== '-') response += `• 등록자: ${registrant}\n`;
+      if (registrantCountry !== '-') response += `• 국가: ${registrantCountry}\n`;
+      response += `\n🌐 기술 정보\n`;
+      response += `• 네임서버: ${nameservers.length ? nameservers.join(', ') : '-'}\n`;
+      if (statuses.length) response += `• 상태: ${statuses.join(', ')}\n`;
+      if (dnssec !== '-') response += `• DNSSEC: ${dnssec}`;
+
+      if (result.available === true) {
+        response += `\n\n✅ 이 도메인은 등록 가능합니다!`;
+      }
+
+      return response.trim();
     }
 
-    if (run.status === 'failed') return '도메인 에이전트 실행 실패';
-    if (maxPolls === 0) return '응답 시간 초과. 다시 시도해주세요.';
-
-    // 5. 메시지 조회
-    const messagesRes = await fetch(`https://api.openai.com/v1/threads/${thread.id}/messages`, {
-      headers: {
-        'Authorization': `Bearer ${apiKey}`,
-        'OpenAI-Beta': 'assistants=v2',
-      },
-    });
-    const messages = await messagesRes.json() as { data: Array<{ role: string; content: Array<{ type: string; text?: { value: string } }> }> };
-    const lastMessage = messages.data[0];
-
-    if (lastMessage?.content?.[0]?.type === 'text') {
-      return lastMessage.content[0].text?.value || '응답 없음';
+    case 'price': {
+      // tld, domain, 또는 ".com" 형식 모두 지원
+      let targetTld = tld || domain?.replace(/^\./, '').split('.').pop();
+      if (!targetTld) return '🚫 TLD를 지정해주세요. (예: com, io, net)';
+      const result = await callNamecheapApi('get_price', { tld: targetTld }, allowedDomains, telegramUserId, db, userId);
+      if (result.error) return `🚫 ${result.error}`;
+      // API 응답: { tld, usd, krw }
+      const price = result.krw || result.register_krw;
+      return `💰 .${targetTld} 도메인 가격\n\n• 등록/갱신: ${price?.toLocaleString()}원/년`;
     }
 
-    return '도메인 에이전트 응답 없음';
-  } catch (error) {
-    return `도메인 에이전트 오류: ${String(error)}`;
+    case 'register': {
+      if (!domain) return '🚫 등록할 도메인을 지정해주세요.';
+      if (!telegramUserId) return '🚫 도메인 등록에는 로그인이 필요합니다.';
+
+      // 1. 가용성 확인
+      const checkResult = await callNamecheapApi('check_domains', { domains: [domain] }, allowedDomains, telegramUserId, db, userId);
+      if (checkResult.error) return `🚫 ${checkResult.error}`;
+      if (!checkResult[domain]) return `❌ ${domain}은 이미 등록된 도메인입니다.`;
+
+      // 2. 가격 조회
+      const domainTld = domain.split('.').pop() || '';
+      const priceResult = await callNamecheapApi('get_price', { tld: domainTld }, allowedDomains, telegramUserId, db, userId);
+      if (priceResult.error) return `🚫 가격 조회 실패: ${priceResult.error}`;
+      const price = priceResult.krw || priceResult.register_krw;
+
+      // 3. 잔액 조회
+      let balance = 0;
+      if (db && userId) {
+        const balanceRow = await db.prepare('SELECT balance FROM user_deposits WHERE user_id = ?').bind(userId).first<{ balance: number }>();
+        balance = balanceRow?.balance || 0;
+      }
+
+      // 4. 확인 페이지 생성 (코드에서 고정 형식)
+      if (balance >= price) {
+        return `📋 도메인 등록 확인
+
+• 도메인: ${domain}
+• 가격: ${price.toLocaleString()}원 (예치금에서 차감)
+• 현재 잔액: ${balance.toLocaleString()}원 ✓
+• 등록 기간: 1년
+
+📌 등록자 정보
+서비스 기본 정보로 등록됩니다.
+(WHOIS Guard가 적용되어 개인정보는 비공개)
+
+⚠️ 주의사항
+도메인 등록 후에는 취소 및 환불이 불가능합니다.
+
+등록을 진행하시려면 '확인'이라고 입력해주세요.`;
+      } else {
+        const shortage = price - balance;
+        return `📋 도메인 등록 확인
+
+• 도메인: ${domain}
+• 가격: ${price.toLocaleString()}원
+• 현재 잔액: ${balance.toLocaleString()}원 ⚠️ 부족
+• 부족 금액: ${shortage.toLocaleString()}원
+
+💳 입금 계좌
+하나은행 427-910018-27104 (주식회사 아이언클래드)
+입금 후 '홍길동 ${shortage}원 입금' 형식으로 알려주세요.`;
+      }
+    }
+
+    default:
+      return `🚫 알 수 없는 작업: ${action}`;
   }
 }
 
@@ -472,13 +824,53 @@ async function executeTool(name: string, args: Record<string, string>, env?: Env
 
     case 'search_web': {
       // Brave Search API
-      const query = args.query;
+      let query = args.query;
       try {
         if (!env?.BRAVE_API_KEY) {
           return `🔍 검색 기능이 설정되지 않았습니다.`;
         }
+
+        // 한글이 포함된 경우 영문으로 번역 (기술 용어, 제품명 등)
+        const hasKorean = /[가-힣]/.test(query);
+        let translatedQuery = query;
+
+        if (hasKorean && env?.OPENAI_API_KEY) {
+          try {
+            const translateRes = await fetch('https://api.openai.com/v1/chat/completions', {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${env.OPENAI_API_KEY}`,
+              },
+              body: JSON.stringify({
+                model: 'gpt-4o-mini',
+                messages: [
+                  {
+                    role: 'system',
+                    content: `사용자의 검색어를 영문으로 번역하세요.
+- 외래어/기술용어는 원래 영문 표기로 변환 (예: 판골린→Pangolin, 도커→Docker)
+- 일반 한국어는 영문으로 번역
+- 검색에 최적화된 키워드로 변환
+- 번역된 검색어만 출력, 설명 없이`
+                  },
+                  { role: 'user', content: query }
+                ],
+                max_tokens: 100,
+                temperature: 0.3,
+              }),
+            });
+            if (translateRes.ok) {
+              const translateData = await translateRes.json() as any;
+              translatedQuery = translateData.choices?.[0]?.message?.content?.trim() || query;
+              console.log(`[search_web] 번역: "${query}" → "${translatedQuery}"`);
+            }
+          } catch {
+            // 번역 실패 시 원본 사용
+          }
+        }
+
         const response = await fetch(
-          `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(query)}&count=5`,
+          `https://api.search.brave.com/res/v1/web/search?q=${encodeURIComponent(translatedQuery)}&count=5`,
           {
             headers: {
               'Accept': 'application/json',
@@ -501,7 +893,12 @@ async function executeTool(name: string, args: Record<string, string>, env?: Env
           `${i + 1}. <b>${r.title}</b>\n   ${r.description}\n   ${r.url}`
         ).join('\n\n');
 
-        return `🔍 검색 결과: ${query}\n\n${results}`;
+        // 번역된 경우 원본 쿼리도 표시
+        const queryDisplay = (hasKorean && translatedQuery !== query)
+          ? `${query} (→ ${translatedQuery})`
+          : query;
+
+        return `🔍 검색 결과: ${queryDisplay}\n\n${results}`;
       } catch (error) {
         return `검색 중 오류가 발생했습니다: ${String(error)}`;
       }
@@ -613,9 +1010,27 @@ async function executeTool(name: string, args: Record<string, string>, env?: Env
       }
     }
 
+    case 'suggest_domains': {
+      const keywords = args.keywords;
+      console.log('[suggest_domains] 시작:', { keywords });
+
+      if (!env?.OPENAI_API_KEY) {
+        return '🚫 도메인 추천 기능이 설정되지 않았습니다.';
+      }
+
+      try {
+        const result = await suggestDomains(keywords, env.OPENAI_API_KEY);
+        console.log('[suggest_domains] 완료:', result?.slice(0, 100));
+        return result;
+      } catch (error) {
+        console.error('[suggest_domains] 오류:', error);
+        return `🚫 도메인 추천 오류: ${String(error)}`;
+      }
+    }
+
     case 'manage_domain': {
-      const query = args.query;
-      console.log('[manage_domain] 시작:', { query, telegramUserId, hasDb: !!db });
+      const { action, domain, nameservers, tld } = args;
+      console.log('[manage_domain] 시작:', { action, domain, telegramUserId, hasDb: !!db });
 
       // 소유권 검증 (DB 조회)
       if (!telegramUserId || !db) {
@@ -624,15 +1039,16 @@ async function executeTool(name: string, args: Record<string, string>, env?: Env
       }
 
       let userDomains: string[] = [];
+      let userId: number | undefined;
       try {
         const user = await db.prepare(
           'SELECT id FROM users WHERE telegram_id = ?'
         ).bind(telegramUserId).first<{ id: number }>();
-        console.log('[manage_domain] user 조회 결과:', user);
 
         if (!user) {
           return '🚫 도메인 관리 권한이 없습니다.';
         }
+        userId = user.id;
 
         // 사용자 소유 도메인 전체 목록 조회
         const domains = await db.prepare(
@@ -640,32 +1056,26 @@ async function executeTool(name: string, args: Record<string, string>, env?: Env
         ).bind(user.id).all<{ domain: string }>();
         userDomains = domains.results?.map(d => d.domain) || [];
         console.log('[manage_domain] 소유 도메인:', userDomains);
-
-        if (userDomains.length === 0) {
-          return '🚫 등록된 도메인이 없습니다. 먼저 도메인을 등록해주세요.';
-        }
       } catch (error) {
         console.log('[manage_domain] DB 오류:', error);
         return '🚫 권한 확인 중 오류가 발생했습니다.';
       }
 
-      if (!env?.OPENAI_API_KEY || !env?.DOMAIN_AGENT_ID) {
-        console.log('[manage_domain] env 설정 없음');
-        return '🌐 도메인 관리 기능이 설정되지 않았습니다.';
-      }
+      // 코드로 직접 처리 (Agent 없이)
       try {
-        console.log('[manage_domain] callDomainAgent 호출 시작');
-        const result = await callDomainAgent(env.OPENAI_API_KEY, env.DOMAIN_AGENT_ID, query, userDomains);
-        console.log('[manage_domain] callDomainAgent 완료:', result?.slice(0, 100));
-        // Markdown → HTML 변환
-        const htmlResult = result
-          .replace(/\*\*(.+?)\*\*/g, '<b>$1</b>')
-          .replace(/\*(.+?)\*/g, '<i>$1</i>')
-          .replace(/`(.+?)`/g, '<code>$1</code>');
-        return `🌐 ${htmlResult}`;
+        const result = await executeDomainAction(
+          action,
+          { domain, nameservers, tld },
+          userDomains,
+          telegramUserId,
+          db,
+          userId
+        );
+        console.log('[manage_domain] 완료:', result?.slice(0, 100));
+        return result;
       } catch (error) {
-        console.log('[manage_domain] callDomainAgent 오류:', error);
-        return `🌐 도메인 관리 오류: ${String(error)}`;
+        console.log('[manage_domain] 오류:', error);
+        return `🚫 도메인 관리 오류: ${String(error)}`;
       }
     }
 
@@ -678,7 +1088,7 @@ async function executeTool(name: string, args: Record<string, string>, env?: Env
 async function callOpenAI(
   apiKey: string,
   messages: OpenAIMessage[],
-  useTools: boolean = true
+  selectedTools?: typeof tools  // undefined = 도구 없음, 배열 = 해당 도구만 사용
 ): Promise<OpenAIResponse> {
   const response = await fetch('https://api.openai.com/v1/chat/completions', {
     method: 'POST',
@@ -689,8 +1099,8 @@ async function callOpenAI(
     body: JSON.stringify({
       model: 'gpt-4o-mini',
       messages,
-      tools: useTools ? tools : undefined,
-      tool_choice: useTools ? 'auto' : undefined,
+      tools: selectedTools?.length ? selectedTools : undefined,
+      tool_choice: selectedTools?.length ? 'auto' : undefined,
       max_tokens: 1000,
     }),
   });
@@ -725,10 +1135,16 @@ export async function generateOpenAIResponse(
     { role: 'user', content: userMessage },
   ];
 
+  // 동적 도구 선택
+  const selectedTools = selectToolsForMessage(userMessage);
+
   // 첫 번째 호출
-  let response = await callOpenAI(env.OPENAI_API_KEY, messages);
+  let response = await callOpenAI(env.OPENAI_API_KEY, messages, selectedTools);
   let assistantMessage = response.choices[0].message;
 
+  console.log('[OpenAI] tool_calls:', assistantMessage.tool_calls ? JSON.stringify(assistantMessage.tool_calls.map(t => ({ name: t.function.name, args: t.function.arguments }))) : 'none');
+  console.log('[OpenAI] content:', assistantMessage.content?.slice(0, 100));
+
   // Function Calling 처리 (최대 3회 반복)
   let iterations = 0;
   while (assistantMessage.tool_calls && iterations < 3) {
@@ -754,12 +1170,14 @@ export async function generateOpenAIResponse(
     });
     messages.push(...toolResults);
 
-    // 다시 호출
-    response = await callOpenAI(env.OPENAI_API_KEY, messages, false);
+    // 다시 호출 (도구 없이 응답 생성)
+    response = await callOpenAI(env.OPENAI_API_KEY, messages, undefined);
     assistantMessage = response.choices[0].message;
   }
 
-  return assistantMessage.content || '응답을 생성할 수 없습니다.';
+  const finalResponse = assistantMessage.content || '응답을 생성할 수 없습니다.';
+
+  return finalResponse;
 }
 
 // 프로필 생성용 (도구 없이)
@@ -774,7 +1192,7 @@ export async function generateProfileWithOpenAI(
   const response = await callOpenAI(
     env.OPENAI_API_KEY,
     [{ role: 'user', content: prompt }],
-    false
+    undefined  // 도구 없이 호출
   );
 
   return response.choices[0].message.content || '프로필 생성 실패';

src/summary-service.ts

@@ -69,30 +69,52 @@ export async function getLatestSummary(
   return summary || null;
 }
 
+// 모든 요약 조회 (최대 3개, 최신순)
+export async function getAllSummaries(
+  db: D1Database,
+  userId: number,
+  chatId: string
+): Promise<Summary[]> {
+  const { results } = await db
+    .prepare(`
+      SELECT id, generation, summary, message_count, created_at
+      FROM summaries
+      WHERE user_id = ? AND chat_id = ?
+      ORDER BY generation DESC
+      LIMIT 3
+    `)
+    .bind(userId, chatId)
+    .all();
+
+  return (results || []) as Summary[];
+}
+
 // 전체 컨텍스트 조회
 export async function getConversationContext(
   db: D1Database,
   userId: number,
   chatId: string
 ): Promise<ConversationContext> {
-  const [previousSummary, recentMessages] = await Promise.all([
-    getLatestSummary(db, userId, chatId),
+  const [summaries, recentMessages] = await Promise.all([
+    getAllSummaries(db, userId, chatId),
     getBufferedMessages(db, userId, chatId),
   ]);
 
+  const previousSummary = summaries[0] || null;  // 최신 요약 (호환성)
   const totalMessages = (previousSummary?.message_count || 0) + recentMessages.length;
 
   return {
     previousSummary,
+    summaries,
     recentMessages,
     totalMessages,
   };
 }
 
-// AI 요약 생성
+// AI 요약 생성 (모든 요약 통합)
 async function generateSummary(
   env: Env,
-  previousSummary: string | null,
+  allSummaries: Summary[],
   messages: BufferedMessage[]
 ): Promise<string> {
   // 사용자 메시지만 추출
@@ -106,29 +128,37 @@ async function generateSummary(
 
   let prompt: string;
 
-  if (previousSummary) {
-    prompt = `당신은 사용자 프로필 분석 전문가입니다.
-기존 사용자 프로필과 새로운 대화를 통합하여 사용자에 대한 이해를 업데이트하세요.
+  if (allSummaries.length > 0) {
+    // 모든 기존 프로필 통합 (오래된 것부터)
+    const existingProfiles = allSummaries
+      .slice()
+      .reverse()
+      .map((s) => `[v${s.generation}] ${s.summary}`)
+      .join('\n\n');
 
-## 기존 사용자 프로필
-${previousSummary}
+    prompt = `당신은 사용자 프로필 분석 전문가입니다.
+기존 사용자 프로필들과 새로운 대화를 통합하여 사용자에 대한 이해를 업데이트하세요.
+
+## 기존 사용자 프로필 (${allSummaries.length}개 버전)
+${existingProfiles}
 
 ## 새로운 사용자 발언 (${userMsgCount}개)
 ${userMessages}
 
 ## 요구사항
-1. **사용자 중심**: 봇 응답은 무시하고 사용자가 말한 내용만 분석
-2. **의미 있는 정보 추출**:
+1. **통합 분석**: 모든 기존 프로필을 종합하고 새로운 정보를 추가
+2. **사용자 중심**: 봇 응답은 무시하고 사용자가 말한 내용만 분석
+3. **의미 있는 정보 추출**:
    - 사용자의 관심사, 취미, 선호도
    - 질문한 주제들 (무엇에 대해 알고 싶어하는지)
    - 요청사항, 목표, 해결하려는 문제
    - 개인적 맥락 (직업, 상황, 배경 등)
-   - 감정 상태나 태도 변화
-3. **무의미한 내용 제외**: 인사말, 단순 확인, 감사 표현 등은 생략
-4. **간결하게**: 300-400자 이내
-5. **한국어로 작성**
+   - 관심사 변화 추이
+4. **무의미한 내용 제외**: 인사말, 단순 확인, 감사 표현 등은 생략
+5. **간결하게**: 400-500자 이내
+6. **한국어로 작성**
 
-업데이트된 사용자 프로필:`;
+통합된 사용자 프로필:`;
   } else {
     prompt = `당신은 사용자 프로필 분석 전문가입니다.
 대화 내용에서 사용자에 대한 정보를 추출하여 프로필을 작성하세요.
@@ -200,17 +230,19 @@ export async function processAndSummarize(
     return { summarized: false };
   }
 
-  const previousSummary = await getLatestSummary(env.DB, userId, chatId);
+  // 모든 기존 요약 조회 (통합 분석용)
+  const allSummaries = await getAllSummaries(env.DB, userId, chatId);
+  const latestSummary = allSummaries[0] || null;
 
-  // AI 요약 생성
+  // AI 요약 생성 (모든 요약 통합)
   const newSummary = await generateSummary(
     env,
-    previousSummary?.summary || null,
+    allSummaries,
     messages
   );
 
-  const newGeneration = (previousSummary?.generation || 0) + 1;
-  const newMessageCount = (previousSummary?.message_count || 0) + messages.length;
+  const newGeneration = (latestSummary?.generation || 0) + 1;
+  const newMessageCount = (latestSummary?.message_count || 0) + messages.length;
 
   // 트랜잭션 실행
   await env.DB.batch([
@@ -242,18 +274,30 @@ export async function generateAIResponse(
 ): Promise<string> {
   const context = await getConversationContext(env.DB, userId, chatId);
 
-  const systemPrompt = `당신은 친절하고 유능한 AI 어시스턴트입니다.
-${context.previousSummary ? `
-## 사용자 프로필
-${context.previousSummary.summary}
+  // 모든 요약 통합 (최신순 → 오래된순으로 정렬하여 시간순 표시)
+  const integratedProfile = context.summaries.length > 0
+    ? context.summaries
+        .slice()
+        .reverse()  // 오래된 것부터 표시
+        .map((s, i) => `[v${s.generation}] ${s.summary}`)
+        .join('\n\n')
+    : null;
 
-위 프로필을 바탕으로 사용자의 관심사와 맥락을 이해하고 개인화된 응답을 제공하세요.
+  const systemPrompt = `당신은 친절하고 유능한 AI 어시스턴트입니다.
+${integratedProfile ? `
+## 사용자 프로필 (${context.summaries.length}개 버전 통합)
+${integratedProfile}
+
+위 프로필들을 종합하여 사용자의 관심사, 맥락, 변화를 이해하고 개인화된 응답을 제공하세요.
+최신 버전(높은 번호)의 정보를 우선시하되, 이전 버전의 맥락도 고려하세요.
 ` : ''}
 - 날씨, 시간, 계산 요청은 제공된 도구를 사용하세요.
-- 최신 정보, 실시간 데이터, 현재 가격, 뉴스, 특정 사실 확인이 필요한 질문은 반드시 search_web 도구로 검색하세요. 자체 지식으로 답변하지 마세요.
+- 최신 정보, 실시간 데이터, 뉴스, 특정 사실 확인이 필요한 질문은 반드시 search_web 도구로 검색하세요. 자체 지식으로 답변하지 마세요.
 - 예치금, 입금, 충전, 잔액, 계좌 관련 요청은 반드시 manage_deposit 도구를 사용하세요. 금액 제한이나 규칙을 직접 판단하지 마세요.
-- 도메인 관련 요청은 반드시 manage_domain 도구를 사용하세요.
-- manage_deposit, manage_domain 도구 결과는 그대로 전달하세요. 추가 질문이나 "도움이 필요하시면~" 같은 멘트를 붙이지 마세요.
+- 도메인 추천, 도메인 제안, 도메인 아이디어 요청은 반드시 suggest_domains 도구를 사용하세요. 직접 도메인을 나열하지 마세요.
+- 도메인/TLD 가격 조회(".com 가격", ".io 가격" 등)는 manage_domain 도구의 action=price를 사용하세요.
+- 기타 도메인 관련 요청(조회, 등록, 네임서버, WHOIS 등)은 manage_domain 도구를 사용하세요.
+- manage_deposit, manage_domain, suggest_domains 도구 결과는 그대로 전달하세요. 추가 질문이나 "도움이 필요하시면~" 같은 멘트를 붙이지 마세요.
 - 응답은 간결하고 도움이 되도록 한국어로 작성하세요.`;
 
   const recentContext = context.recentMessages.slice(-10).map((m) => ({

src/types.ts

@@ -7,12 +7,12 @@ export interface Env {
   MAX_SUMMARIES_PER_USER?: string;
   N8N_WEBHOOK_URL?: string;
   OPENAI_API_KEY?: string;
-  DOMAIN_AGENT_ID?: string;
   NAMECHEAP_API_KEY?: string;
   DOMAIN_OWNER_ID?: string;
   DEPOSIT_AGENT_ID?: string;
   DEPOSIT_ADMIN_ID?: string;
   BRAVE_API_KEY?: string;
+  DEPOSIT_API_SECRET?: string;
 }
 
 export interface IntentAnalysis {
@@ -68,7 +68,8 @@ export interface Summary {
 }
 
 export interface ConversationContext {
-  previousSummary: Summary | null;
+  previousSummary: Summary | null;  // 최신 요약 (호환성 유지)
+  summaries: Summary[];             // 전체 요약 (최대 3개, 최신순)
   recentMessages: BufferedMessage[];
   totalMessages: number;
 }