korean-law-mcp 4.4.0 → 4.4.2

package/build/lib/api-client.js

@@ -233,8 +233,8 @@ export class LawApiClient {
         if (/시행령|시행규칙/.test(lawName)) {
             return 'law';
         }
-        // 행정규칙: 훈령, 예규, 고시, 지침, 내규
-        if (/훈령|예규|고시|지침|내규/.test(lawName)) {
+        // 행정규칙: 훈령, 예규, 고시, 지침, 내규, 세칙 (규정/규칙 단독은 시행규칙 오분류 위험 → 4차 fallback에 위임)
+        if (/훈령|예규|고시|지침|내규|세칙/.test(lawName)) {
             return 'admin';
         }
         // 일반 법령 (법, 규정 등)

package/build/server/sse-server.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Streamable HTTP 서버 - 리모트 배포용 (MCP 2025-03-26 스펙 준수)
+ */
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export declare function startSSEServer(server: Server, port: number): Promise<void>;

package/build/server/sse-server.js

@@ -0,0 +1,232 @@
+/**
+ * Streamable HTTP 서버 - 리모트 배포용 (MCP 2025-03-26 스펙 준수)
+ */
+import express from "express";
+import { randomUUID } from "node:crypto";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { InMemoryEventStore } from "@modelcontextprotocol/sdk/examples/shared/inMemoryEventStore.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+import { sessionStore, setSessionApiKey, deleteSession } from "../lib/session-state.js";
+import { VERSION } from "../version.js";
+export async function startSSEServer(server, port) {
+    const app = express();
+    const transports = {};
+    // JSON 파싱 미들웨어 (크기 제한 명시)
+    app.use(express.json({ limit: "100kb" }));
+    // 유휴 세션 정리 (30분)
+    const SESSION_IDLE_TIMEOUT = 30 * 60 * 1000;
+    const MAX_SESSIONS = 100;
+    setInterval(() => {
+        const now = Date.now();
+        for (const sid of Object.keys(transports)) {
+            const session = transports[sid];
+            if (session.lastAccess && now - session.lastAccess > SESSION_IDLE_TIMEOUT) {
+                try {
+                    session.transport.close();
+                }
+                catch { /* ignore */ }
+                delete transports[sid];
+                deleteSession(sid);
+            }
+        }
+    }, 5 * 60 * 1000).unref();
+    // CORS 및 보안 헤더 설정
+    const corsOrigin = process.env.CORS_ORIGIN || "*";
+    app.use((req, res, next) => {
+        res.header("Access-Control-Allow-Origin", corsOrigin);
+        res.header("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS, HEAD");
+        res.header("Access-Control-Allow-Headers", "Content-Type, Accept, Authorization, Mcp-Protocol-Version, mcp-protocol-version, Mcp-Session-Id, mcp-session-id, Last-Event-ID, last-event-id, Traceparent, Tracestate");
+        res.header("Access-Control-Expose-Headers", "Mcp-Session-Id, Content-Type, Mcp-Protocol-Version, Traceparent, Tracestate");
+        res.header("Access-Control-Max-Age", "86400");
+        // Security headers (http-server.ts와 동일)
+        res.header("X-Content-Type-Options", "nosniff");
+        res.header("X-Frame-Options", "DENY");
+        res.header("Referrer-Policy", "strict-origin-when-cross-origin");
+        res.header("Mcp-Protocol-Version", "2025-03-26");
+        if (req.method === "OPTIONS") {
+            return res.sendStatus(200);
+        }
+        next();
+    });
+    // 헬스체크 엔드포인트
+    app.get("/", (req, res) => {
+        res.json({
+            name: "Korean Law MCP Server",
+            version: VERSION,
+            status: "running",
+            protocol: "streamable-http",
+            endpoints: {
+                mcp: "/mcp",
+                health: "/health"
+            }
+        });
+    });
+    app.get("/health", (req, res) => {
+        res.json({ status: "ok", timestamp: new Date().toISOString() });
+    });
+    // MCP POST 엔드포인트 (초기화 및 요청 처리)
+    app.post("/mcp", async (req, res) => {
+        const sessionId = req.headers["mcp-session-id"];
+        // API 키 추출 (http-server.ts와 동일 패턴)
+        const apiKeyFromHeader = req.headers["apikey"] ||
+            req.headers["law_oc"] ||
+            req.headers["law-oc"] ||
+            req.headers["LAW_OC"] ||
+            req.headers["x-api-key"] ||
+            req.headers["authorization"]?.replace(/^Bearer\s+/i, "") ||
+            req.headers["x-law-oc"];
+        if (sessionId) {
+            console.error(`Received MCP request for session: ${sessionId.slice(0, 8)}...`);
+        }
+        else {
+            console.error("New MCP request (no session ID)");
+        }
+        try {
+            let transport;
+            if (sessionId && transports[sessionId]) {
+                // 기존 세션 재사용 + 접근 시각 갱신
+                ;
+                transports[sessionId].lastAccess = Date.now();
+                transport = transports[sessionId].transport;
+                // API 키 업데이트 (헤더에서 제공된 경우)
+                if (apiKeyFromHeader) {
+                    setSessionApiKey(sessionId, apiKeyFromHeader);
+                }
+                // AsyncLocalStorage로 세션 ID 격리 (동시 요청 안전)
+                await sessionStore.run(sessionId, async () => {
+                    await transport.handleRequest(req, res, req.body);
+                });
+                return;
+            }
+            else if (!sessionId && isInitializeRequest(req.body)) {
+                // 새 세션 초기화
+                // 세션 수 제한 — transport 생성 전에 체크하여 리소스 누수 방지
+                if (Object.keys(transports).length >= MAX_SESSIONS) {
+                    res.status(503).json({
+                        jsonrpc: "2.0",
+                        error: { code: -32000, message: `Max sessions (${MAX_SESSIONS}) reached. Try again later.` },
+                        id: null,
+                    });
+                    return;
+                }
+                const eventStore = new InMemoryEventStore();
+                transport = new StreamableHTTPServerTransport({
+                    sessionIdGenerator: () => randomUUID(),
+                    eventStore,
+                    onsessioninitialized: (newSessionId) => {
+                        transports[newSessionId] = { transport, lastAccess: Date.now() };
+                        if (apiKeyFromHeader) {
+                            setSessionApiKey(newSessionId, apiKeyFromHeader);
+                        }
+                    }
+                });
+                // 세션 종료 시 정리
+                transport.onclose = () => {
+                    const sid = transport.sessionId;
+                    if (sid && transports[sid]) {
+                        console.error(`Transport closed for session ${sid.slice(0, 8)}...`);
+                        delete transports[sid];
+                        deleteSession(sid);
+                    }
+                };
+                // 서버 연결
+                await server.connect(transport);
+                await transport.handleRequest(req, res, req.body);
+                return;
+            }
+            else {
+                // 잘못된 요청
+                res.status(400).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32000,
+                        message: "Invalid request: missing session ID or not an initialization request"
+                    },
+                    id: null
+                });
+                return;
+            }
+        }
+        catch (error) {
+            console.error("Error handling MCP POST request:", error);
+            if (!res.headersSent) {
+                res.status(500).json({
+                    jsonrpc: "2.0",
+                    error: {
+                        code: -32603,
+                        message: "Internal server error"
+                    },
+                    id: null
+                });
+            }
+        }
+    });
+    // MCP GET 엔드포인트 (SSE 스트림)
+    app.get("/mcp", async (req, res) => {
+        const sessionId = req.headers["mcp-session-id"];
+        if (!sessionId || !transports[sessionId]) {
+            res.status(400).send("Invalid or missing session ID");
+            return;
+        }
+        const lastEventId = req.headers["last-event-id"];
+        if (lastEventId) {
+            console.error(`Client reconnecting with Last-Event-ID: ${lastEventId}`);
+        }
+        else {
+            console.error(`Establishing SSE stream for session ${sessionId.slice(0, 8)}...`);
+        }
+        try {
+            const transport = transports[sessionId].transport;
+            await transport.handleRequest(req, res);
+        }
+        catch (error) {
+            console.error("[GET /mcp] Error:", error);
+            if (!res.headersSent) {
+                res.status(500).send("Internal server error");
+            }
+        }
+    });
+    // MCP DELETE 엔드포인트 (세션 종료)
+    app.delete("/mcp", async (req, res) => {
+        const sessionId = req.headers["mcp-session-id"];
+        if (!sessionId || !transports[sessionId]) {
+            res.status(400).send("Invalid or missing session ID");
+            return;
+        }
+        console.error(`Session termination request for ${sessionId.slice(0, 8)}...`);
+        try {
+            const transport = transports[sessionId].transport;
+            await transport.handleRequest(req, res);
+            delete transports[sessionId];
+            deleteSession(sessionId);
+            console.error(`Session removed: ${sessionId.slice(0, 8)}...`);
+        }
+        catch (error) {
+            console.error("Error handling session termination:", error);
+            if (!res.headersSent) {
+                res.status(500).send("Error processing session termination");
+            }
+        }
+    });
+    // 서버 시작
+    app.listen(port, "0.0.0.0", () => {
+        console.error(`✓ Korean Law MCP server (Streamable HTTP) listening on port ${port}`);
+        console.error(`✓ MCP endpoint: http://0.0.0.0:${port}/mcp`);
+        console.error(`✓ Health check: http://0.0.0.0:${port}/health`);
+    });
+    // 종료 처리
+    process.on("SIGINT", async () => {
+        console.error("Shutting down server...");
+        for (const sessionId in transports) {
+            try {
+                await transports[sessionId].transport.close();
+                delete transports[sessionId];
+                deleteSession(sessionId);
+            }
+            catch (error) {
+                console.error(`Error closing transport ${sessionId}:`, error);
+            }
+        }
+        process.exit(0);
+    });
+}

package/build/tool-registry.d.ts

@@ -9,6 +9,10 @@ import type { McpTool } from "./lib/types.js";
  * 모든 MCP 도구 정의
  */
 export declare const allTools: McpTool[];
+/**
+ * Zod 스키마 → MCP 광고용 JSON Schema 변환 (apiKey 숨김 포함)
+ */
+export declare function toMcpInputSchema(schema: unknown): any;
 /** 노출/전체 도구 수 — 헬스체크 등 표기용 파생값 (하드코딩 금지) */
 export declare const TOOL_COUNTS: {
     exposed: number;

package/build/tool-registry.js

@@ -680,11 +680,13 @@ export const allTools = [
     },
 ];
 /**
- * ZodEffects(.refine(), .transform() 등)를 벗겨내고 내부 ZodObject를 반환
+ * Zod 스키마 → MCP 광고용 JSON Schema 변환 (apiKey 숨김 포함)
  */
-function toMcpInputSchema(schema) {
+export function toMcpInputSchema(schema) {
     // Zod v4: z.toJSONSchema()로 직접 변환 (zod-to-json-schema는 Zod v4 미지원)
-    const rawSchema = z.toJSONSchema(schema);
+    // io:"input" 필수 — 기본 "output" 모드는 .default() 필드를 required로 직렬화함
+    // (legal_research.task, search_law.display가 required로 광고되던 버그, v4.4.1)
+    const rawSchema = z.toJSONSchema(schema, { io: "input" });
     if (rawSchema?.type === "object" && rawSchema?.properties) {
         // apiKey는 HTTP 헤더(session-state)로 전달되는 게 정식 경로 — 광고 스키마에서 숨김.
         // Zod parse는 여전히 수용하므로 인자로 넘기는 기존 클라이언트도 동작.

package/build/tools/annex.js

@@ -9,7 +9,7 @@ import { formatToolError, notFoundResponse } from "../lib/errors.js";
 import { getLawSiteBaseUrl } from "../lib/law-url-config.js";
 const LAW_BASE_URL = getLawSiteBaseUrl();
 export const GetAnnexesSchema = z.object({
-    lawName: z.string().describe("법령명 (예: '관세법'). 별표를 바로 지정하려면 '... 별표4'처럼 함께 입력 가능"),
+    lawName: z.string().describe("법령명 (예: '관세법'). 별표를 바로 지정하려면 '... 별표4' 또는 '... 별표1의2'처럼 함께 입력 가능"),
     knd: z.enum(["1", "2", "3", "4", "5"]).optional().describe("1=별표, 2=서식, 3=부칙별표, 4=부칙서식, 5=전체"),
     bylSeq: z.string().optional().describe("별표번호 (예: '000300'). 지정 시 해당 별표 파일을 다운로드하여 텍스트로 추출"),
     annexNo: z.string().optional().describe("별표 번호 (예: '4', '별표4', '제4호'). bylSeq 대체 입력"),
@@ -29,8 +29,9 @@ export async function getAnnexes(apiClient, input) {
                 const json = JSON.parse(jsonText);
                 const adminResult = json?.admRulBylSearch;
                 const licResult = json?.licBylSearch;
-                if (adminResult?.admbyl)
-                    return { list: toArray(adminResult.admbyl), type: "admin" };
+                // 법제처 행정규칙 별표 응답의 배열 키는 admrulbyl (admbyl 아님). 구버전 호환 위해 admbyl도 폴백.
+                if (adminResult?.admrulbyl ?? adminResult?.admbyl)
+                    return { list: toArray(adminResult.admrulbyl ?? adminResult.admbyl), type: "admin" };
                 if (licResult?.ordinbyl)
                     return { list: toArray(licResult.ordinbyl), type: "ordinance" };
                 if (licResult?.licbyl)
@@ -109,7 +110,7 @@ export async function getAnnexes(apiClient, input) {
         const filtered = filterByRelatedLawName(annexList, normalizedLawName);
         // 별표 선택값 지정 시 → 해당 별표 파일 다운로드 + 텍스트 추출
         if (annexSelector) {
-            return await extractAnnexContent(filtered, annexSelector, normalizedLawName);
+            return await extractAnnexContent(filtered, annexSelector, normalizedLawName, input.knd);
         }
         // 별표 선택값 미지정 → 기존 목록 반환
         return formatAnnexList(filtered, lawType, input, normalizedLawName);
@@ -119,9 +120,9 @@ export async function getAnnexes(apiClient, input) {
     }
 }
 // ─── 별표 텍스트 추출 ─────────────────────────────────
-async function extractAnnexContent(annexList, annexSelector, normalizedLawName) {
-    // bylSeq / annexNo / lawName 내 힌트로 유연 매칭
-    const matched = findMatchingAnnex(annexList, annexSelector);
+async function extractAnnexContent(annexList, annexSelector, normalizedLawName, knd) {
+    // bylSeq / annexNo / lawName 내 힌트로 유연 매칭 (별표/서식 구분 위해 knd 전달)
+    const matched = findMatchingAnnex(annexList, annexSelector, knd);
     if (!matched) {
         const availableBylSeq = annexList.map((a) => a.별표번호).filter(Boolean).slice(0, 20).join(", ");
         return notFoundResponse(`별표 선택값 "${annexSelector}"에 해당하는 항목을 찾을 수 없습니다. (법령: ${normalizedLawName})`, [
@@ -219,8 +220,9 @@ function formatAnnexList(annexList, lawType, input, normalizedLawName) {
         else if (lawType === "admin") {
             if (annex.관련행정규칙명)
                 resultText += `   행정규칙: ${annex.관련행정규칙명}\n`;
-            if (annex.소관부처)
-                resultText += `   소관부처: ${annex.소관부처}\n`;
+            const dept = annex.소관부처명 || annex.소관부처;
+            if (dept)
+                resultText += `   소관부처: ${dept}\n`;
         }
         else {
             if (annex.관련법령명)
@@ -245,24 +247,45 @@ function extractParentLawName(lawName) {
 }
 function parseLawNameAndHint(lawName) {
     const trimmedLawName = lawName.trim();
-    const annexHintMatch = trimmedLawName.match(/\[?\s*(별표|서식)\s*(?:제)?\s*(\d{1,6})\s*(?:호)?\s*\]?/);
+    // "별표1", "별표 제1호", "별표 1의2"(= 별표 제1호의2) 모두 매칭. 의-번호는 별도 캡처해 법령명에 남지 않게 한다.
+    const annexHintMatch = trimmedLawName.match(/\[?\s*(별표|서식)\s*(?:제)?\s*(\d{1,6})\s*(?:호)?\s*(?:의\s*(\d{1,2}))?\s*\]?/);
     if (!annexHintMatch) {
         return { normalizedLawName: trimmedLawName };
     }
-    const parsedAnnexNo = Number.parseInt(annexHintMatch[2], 10);
+    const mainNo = Number.parseInt(annexHintMatch[2], 10);
+    const subNo = annexHintMatch[3] ? Number.parseInt(annexHintMatch[3], 10) : null;
     const normalizedLawName = trimmedLawName
         .replace(annexHintMatch[0], " ")
         .replace(/\s+/g, " ")
         .trim();
+    if (Number.isNaN(mainNo)) {
+        return { normalizedLawName: normalizedLawName || trimmedLawName };
+    }
+    // 의-번호가 있으면 법제처 별표번호 6자리 코드(AAAABB)로 변환 (별표 1의2 → "000102").
+    // 없으면 기존 동작 유지(정수 문자열 → buildSelectorCandidates가 6자리 코드 후보 생성).
+    const annexNo = subNo != null
+        ? String(mainNo).padStart(4, "0") + String(subNo).padStart(2, "0")
+        : String(mainNo);
     return {
         normalizedLawName: normalizedLawName || trimmedLawName,
-        annexNo: Number.isNaN(parsedAnnexNo) ? undefined : String(parsedAnnexNo)
+        annexNo
     };
 }
-function findMatchingAnnex(annexList, annexSelector) {
+/**
+ * 별표 선택값으로 항목 매칭.
+ *
+ * 자치법규 등에서 [별표 N]과 [별지 제N호서식]이 동일 별표번호(bylSeq)를 공유하는 경우가
+ * 있어, 번호만으로 find() 하면 목록 순서상 먼저 오는 항목(주로 서식)이 잘못 선택된다.
+ * (예: 서울특별시 건축 조례 — [별표4] 대지안의 공지기준 / [별지 제4호서식] 공개공지 관리대장이
+ *  모두 별표번호 000400을 가짐.)
+ * 따라서 번호가 일치하는 후보를 모두 모은 뒤, knd(별표/서식 의도)로 별표종류를 구분해
+ * 올바른 항목을 고른다. knd 미지정 시 표(별표)를 서식보다 우선한다.
+ */
+function findMatchingAnnex(annexList, annexSelector, knd) {
     const selectorCandidates = buildSelectorCandidates(annexSelector);
     const selectorNumbers = extractSelectorNumbers(annexSelector);
-    return annexList.find((annex) => {
+    // 번호/제목으로 매칭되는 후보 "전체" 수집 (find → filter)
+    const matches = annexList.filter((annex) => {
         const annexNum = String(annex.별표번호 || "").trim();
         const annexTitle = String(annex.별표명 || "");
         if (annexNum && selectorCandidates.has(annexNum)) {
@@ -270,6 +293,23 @@ function findMatchingAnnex(annexList, annexSelector) {
         }
         return selectorNumbers.some((num) => titleMatchesAnnexNumber(annexTitle, num));
     });
+    if (matches.length === 0)
+        return undefined;
+    if (matches.length === 1)
+        return matches[0];
+    // 별표번호 충돌 → 별표종류("별표"/"서식")로 구분
+    const isForm = (a) => /서식/.test(String(a.별표종류 || ""));
+    const isTable = (a) => /별표/.test(String(a.별표종류 || ""));
+    if (knd === "2" || knd === "4") {
+        // 서식을 명시적으로 요청
+        return matches.find(isForm) || matches[0];
+    }
+    if (knd === "1" || knd === "3") {
+        // 별표를 명시적으로 요청
+        return matches.find(isTable) || matches[0];
+    }
+    // knd 미지정/전체(5): 표(별표)를 서식보다 우선
+    return matches.find(isTable) || matches[0];
 }
 function buildSelectorCandidates(selector) {
     const candidates = new Set();

package/build/tools/legal-analysis.d.ts

@@ -4,7 +4,8 @@
  * verify_citations·cite_check·applicable_law·impact_map을 mode 파라미터로
  * 통합해 MCP 노출 도구 수를 줄인다. 원본 도구는 allTools에 그대로 남아
  * 직접 호출/execute_tool 경유가 계속 동작한다 (하위호환).
- * 세부 옵션(deepScan, includeMermaid 등)은 원본 도구의 기본값을 따른다.
+ * 비용이 큰 옵션(deepScan, includeOrdinances, includeMermaid 등)은
+ * 패스스루로 노출 — 기본값은 원본 도구와 동일 (v4.4.1).
  */
 import { z } from "zod";
 import type { LawApiClient } from "../lib/api-client.js";
@@ -21,6 +22,11 @@ export declare const LegalAnalysisSchema: z.ZodObject<{
     lawName: z.ZodOptional<z.ZodString>;
     jo: z.ZodOptional<z.ZodString>;
     date: z.ZodOptional<z.ZodString>;
+    maxCitations: z.ZodOptional<z.ZodNumber>;
+    display: z.ZodOptional<z.ZodNumber>;
+    deepScan: z.ZodOptional<z.ZodBoolean>;
+    includeOrdinances: z.ZodOptional<z.ZodBoolean>;
+    includeMermaid: z.ZodOptional<z.ZodBoolean>;
     apiKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type LegalAnalysisInput = z.infer<typeof LegalAnalysisSchema>;

package/build/tools/legal-analysis.js

@@ -4,7 +4,8 @@
  * verify_citations·cite_check·applicable_law·impact_map을 mode 파라미터로
  * 통합해 MCP 노출 도구 수를 줄인다. 원본 도구는 allTools에 그대로 남아
  * 직접 호출/execute_tool 경유가 계속 동작한다 (하위호환).
- * 세부 옵션(deepScan, includeMermaid 등)은 원본 도구의 기본값을 따른다.
+ * 비용이 큰 옵션(deepScan, includeOrdinances, includeMermaid 등)은
+ * 패스스루로 노출 — 기본값은 원본 도구와 동일 (v4.4.1).
  */
 import { z } from "zod";
 import { verifyCitations } from "./verify-citations.js";
@@ -24,6 +25,16 @@ export const LegalAnalysisSchema = z.object({
         .describe("[impact_map 필수, applicable_law 선택] 조문 번호 (예: '제103조', '제10조의2')"),
     date: z.string().optional()
         .describe("[applicable_law 필수] 기준일 — 행위·계약·처분 시점 (예: '2023-05-10', '20230510')"),
+    maxCitations: z.number().min(1).max(30).optional()
+        .describe("[verify_citations] 검증할 최대 인용 개수 (기본 15, 많을수록 느림)"),
+    display: z.number().min(1).max(50).optional()
+        .describe("[cite_check] 후속 인용 판례 최대 표시 수 (기본 20)"),
+    deepScan: z.boolean().optional()
+        .describe("[cite_check] 후속 인용 상위 판례 본문 정밀 스캔 (기본 true, false면 빠르지만 변경·폐기 감지 생략)"),
+    includeOrdinances: z.boolean().optional()
+        .describe("[impact_map] 자치법규 인용 검색 포함 (기본 true, false면 전국 조례 팬아웃 생략)"),
+    includeMermaid: z.boolean().optional()
+        .describe("[impact_map] mermaid 그래프 코드 출력 (기본 true)"),
     apiKey: z.string().optional(),
 });
 function inputError(message) {
@@ -35,11 +46,18 @@ export async function legalAnalysis(apiClient, input) {
         case "verify_citations":
             if (!input.text)
                 return inputError("mode=verify_citations에는 text가 필요합니다.");
-            return verifyCitations(apiClient, { text: input.text, maxCitations: 15, apiKey });
+            return verifyCitations(apiClient, {
+                text: input.text, maxCitations: input.maxCitations ?? 15, apiKey,
+            });
         case "cite_check":
             if (!input.caseNumber)
                 return inputError("mode=cite_check에는 caseNumber가 필요합니다.");
-            return citeCheck(apiClient, { caseNumber: input.caseNumber, display: 20, deepScan: true, apiKey });
+            return citeCheck(apiClient, {
+                caseNumber: input.caseNumber,
+                display: input.display ?? 20,
+                deepScan: input.deepScan ?? true,
+                apiKey,
+            });
         case "applicable_law":
             if (!input.lawName || !input.date)
                 return inputError("mode=applicable_law에는 lawName과 date가 필요합니다.");
@@ -49,7 +67,9 @@ export async function legalAnalysis(apiClient, input) {
                 return inputError("mode=impact_map에는 lawName과 jo가 필요합니다.");
             return impactMap(apiClient, {
                 lawName: input.lawName, jo: input.jo,
-                includeOrdinances: true, includeMermaid: true, apiKey,
+                includeOrdinances: input.includeOrdinances ?? true,
+                includeMermaid: input.includeMermaid ?? true,
+                apiKey,
             });
     }
 }

package/build/tools/legal-research.d.ts

@@ -4,10 +4,13 @@
  * 기존 chain_* 8개를 task 파라미터 하나로 통합해 MCP 노출 도구 수와
  * ListTools 컨텍스트 비용을 줄인다. 기존 chain_* 도구는 allTools에
  * 그대로 남아 직접 호출/execute_tool 경유가 계속 동작한다 (하위호환).
+ *
+ * task별 허용 scenario는 체인 스키마(chains.ts)에서 직접 파생 —
+ * 별도 호환표를 두지 않아 체인 쪽 enum 변경 시 자동 추종된다 (v4.4.1).
  */
 import { z } from "zod";
 import type { LawApiClient } from "../lib/api-client.js";
-import { chainFullResearch } from "./chains.js";
+import type { LooseToolResponse } from "../lib/types.js";
 export declare const LegalResearchSchema: z.ZodObject<{
     query: z.ZodOptional<z.ZodString>;
     task: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
@@ -49,6 +52,17 @@ export declare const LegalResearchSchema: z.ZodObject<{
     apiKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type LegalResearchInput = z.infer<typeof LegalResearchSchema>;
-type ToolResponse = Awaited<ReturnType<typeof chainFullResearch>>;
+type ToolResponse = LooseToolResponse;
+/**
+ * 체인 스키마의 scenario 필드로 입력 scenario를 검증한다.
+ * 비호환이면 버리고(자동 감지로 폴백) 경고 노트를 함께 반환 —
+ * 호출 LLM이 자기 파라미터가 무시된 것을 알 수 있게 한다.
+ */
+export declare function pickScenario<S extends z.ZodType>(schema: S, scenario: string | undefined, task: string): {
+    value: z.infer<S>;
+    note?: string;
+};
+/** 경고 노트를 응답 첫 줄에 주입 */
+export declare function withNote(note: string | undefined, res: ToolResponse): ToolResponse;
 export declare function legalResearch(apiClient: LawApiClient, input: LegalResearchInput): Promise<ToolResponse>;
 export {};

package/build/tools/legal-research.js

@@ -4,9 +4,12 @@
  * 기존 chain_* 8개를 task 파라미터 하나로 통합해 MCP 노출 도구 수와
  * ListTools 컨텍스트 비용을 줄인다. 기존 chain_* 도구는 allTools에
  * 그대로 남아 직접 호출/execute_tool 경유가 계속 동작한다 (하위호환).
+ *
+ * task별 허용 scenario는 체인 스키마(chains.ts)에서 직접 파생 —
+ * 별도 호환표를 두지 않아 체인 쪽 enum 변경 시 자동 추종된다 (v4.4.1).
  */
 import { z } from "zod";
-import { chainLawSystem, chainActionBasis, chainDisputePrep, chainAmendmentTrack, chainOrdinanceCompare, chainFullResearch, chainProcedureDetail, chainDocumentReview, } from "./chains.js";
+import { chainLawSystem, chainLawSystemSchema, chainActionBasis, chainActionBasisSchema, chainDisputePrep, chainAmendmentTrack, chainAmendmentTrackSchema, chainOrdinanceCompare, chainOrdinanceCompareSchema, chainFullResearch, chainFullResearchSchema, chainProcedureDetail, chainProcedureDetailSchema, chainDocumentReview, } from "./chains.js";
 export const LegalResearchSchema = z.object({
     query: z.string().optional()
         .describe("자연어 질문/법령명/키워드 (예: '음주운전 처벌 기준', '관세법 체계'). document_review 외 모든 task에서 필수"),
@@ -38,68 +41,84 @@ export const LegalResearchSchema = z.object({
         .describe("[document_review] 최대 분석 조항 수 (기본 15)"),
     apiKey: z.string().optional(),
 });
-/** task별 허용 시나리오 — 비호환 시나리오는 무시하고 자동 감지에 맡긴다 */
-const TASK_SCENARIOS = {
-    law_system: new Set(["delegation", "impact"]),
-    action_basis: new Set(["penalty"]),
-    amendment_track: new Set(["timeline", "time_travel"]),
-    ordinance_compare: new Set(["compliance"]),
-    full_research: new Set(["customs", "action_plan"]),
-    procedure_detail: new Set(["manual"]),
-};
 function inputError(message) {
     return { content: [{ type: "text", text: message }], isError: true };
 }
+/**
+ * 체인 스키마의 scenario 필드로 입력 scenario를 검증한다.
+ * 비호환이면 버리고(자동 감지로 폴백) 경고 노트를 함께 반환 —
+ * 호출 LLM이 자기 파라미터가 무시된 것을 알 수 있게 한다.
+ */
+export function pickScenario(schema, scenario, task) {
+    const result = schema.safeParse(scenario);
+    if (result.success)
+        return { value: result.data };
+    return {
+        value: undefined,
+        note: `⚠ scenario=${scenario}는 task=${task}와 비호환이라 무시하고 자동 감지로 대체했습니다.`,
+    };
+}
+/** 경고 노트를 응답 첫 줄에 주입 */
+export function withNote(note, res) {
+    if (!note)
+        return res;
+    return { ...res, content: [{ type: "text", text: note }, ...res.content] };
+}
+/** scenario 필드가 없는 task에 scenario가 들어온 경우의 경고 */
+function droppedNote(scenario, task) {
+    return scenario
+        ? `⚠ task=${task}는 scenario를 지원하지 않아 scenario=${scenario}를 무시했습니다.`
+        : undefined;
+}
 export async function legalResearch(apiClient, input) {
     const task = input.task ?? "full_research";
     if (task === "document_review") {
         if (!input.text)
             return inputError("task=document_review에는 text(문서 전문)가 필요합니다.");
-        return chainDocumentReview(apiClient, {
+        return withNote(droppedNote(input.scenario, task), await chainDocumentReview(apiClient, {
             text: input.text,
             maxClauses: input.maxClauses ?? 15,
             apiKey: input.apiKey,
-        });
+        }));
     }
     if (!input.query)
         return inputError(`task=${task}에는 query가 필요합니다.`);
     const query = input.query;
-    // 비호환 시나리오는 버리고 각 체인의 자동 감지에 맡긴다
-    const scenario = input.scenario && TASK_SCENARIOS[task]?.has(input.scenario)
-        ? input.scenario
-        : undefined;
     const apiKey = input.apiKey;
     switch (task) {
-        case "law_system":
-            return chainLawSystem(apiClient, {
-                query, articles: input.articles,
-                scenario: scenario, apiKey,
-            });
-        case "action_basis":
-            return chainActionBasis(apiClient, {
-                query, scenario: scenario, apiKey,
-            });
+        case "law_system": {
+            const { value: scenario, note } = pickScenario(chainLawSystemSchema.shape.scenario, input.scenario, task);
+            return withNote(note, await chainLawSystem(apiClient, {
+                query, articles: input.articles, scenario, apiKey,
+            }));
+        }
+        case "action_basis": {
+            const { value: scenario, note } = pickScenario(chainActionBasisSchema.shape.scenario, input.scenario, task);
+            return withNote(note, await chainActionBasis(apiClient, { query, scenario, apiKey }));
+        }
         case "dispute_prep":
-            return chainDisputePrep(apiClient, { query, domain: input.domain, apiKey });
-        case "amendment_track":
-            return chainAmendmentTrack(apiClient, {
-                query, mst: input.mst, lawId: input.lawId,
-                scenario: scenario,
+            return withNote(droppedNote(input.scenario, task), await chainDisputePrep(apiClient, { query, domain: input.domain, apiKey }));
+        case "amendment_track": {
+            const { value: scenario, note } = pickScenario(chainAmendmentTrackSchema.shape.scenario, input.scenario, task);
+            return withNote(note, await chainAmendmentTrack(apiClient, {
+                query, mst: input.mst, lawId: input.lawId, scenario,
                 fromDate: input.fromDate, toDate: input.toDate, apiKey,
-            });
-        case "ordinance_compare":
-            return chainOrdinanceCompare(apiClient, {
-                query, parentLaw: input.parentLaw,
-                scenario: scenario, apiKey,
-            });
-        case "procedure_detail":
-            return chainProcedureDetail(apiClient, {
-                query, scenario: scenario, apiKey,
-            });
+            }));
+        }
+        case "ordinance_compare": {
+            const { value: scenario, note } = pickScenario(chainOrdinanceCompareSchema.shape.scenario, input.scenario, task);
+            return withNote(note, await chainOrdinanceCompare(apiClient, {
+                query, parentLaw: input.parentLaw, scenario, apiKey,
+            }));
+        }
+        case "procedure_detail": {
+            const { value: scenario, note } = pickScenario(chainProcedureDetailSchema.shape.scenario, input.scenario, task);
+            return withNote(note, await chainProcedureDetail(apiClient, { query, scenario, apiKey }));
+        }
         case "full_research":
-        default:
-            return chainFullResearch(apiClient, {
-                query, scenario: scenario, apiKey,
-            });
+        default: {
+            const { value: scenario, note } = pickScenario(chainFullResearchSchema.shape.scenario, input.scenario, task);
+            return withNote(note, await chainFullResearch(apiClient, { query, scenario, apiKey }));
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "korean-law-mcp",
-  "version": "4.4.0",
+  "version": "4.4.2",
   "description": "법제처 42개 API → 9개 MCP 도구. 법령·판례·조례·조약 + 다단계 리서치(legal_research, 8 task) + 정밀분석(legal_analysis: 인용검증·판례생사·행위시법·영향그래프) + 시점 비교(time_travel) + 상황별 5단계 안내(action_plan) + 국세청 해석례(nts)",
   "type": "module",
   "main": "build/index.js",